Apparatuses, methods and systems for a distributed object renderer

ABSTRACT

APPARATUSES, METHODS AND SYSTEMS FOR A DISTRIBUTED OBJECT RENDERER implement distributed rendering of complex visualizations in rich multimedia objects for sharing in online social networking applications. In one embodiment, a processor-implemented distributed rendering method is disclosed, comprising: obtaining a request to render an image of a visualization included in a client app; analyzing the render request to determine data required for render processing; providing a request for the data required for render processing; obtaining the data required for render processing upon providing the request for the required data; recreating an app state of the client app using the obtained data required for render processing, the recreated app state including data related to the visualization included in the client app; rendering the image of the visualization including in the client app using the recreated app state; generating a publishing element using the rendered image of the visualization included in the client app; and providing the publishing element for publication.

PRIORITY CLAIM

Applicant hereby claims priority under 35 USC §119 for U.S. provisionalpatent application Ser. No. 61/238,136 filed Aug. 28, 2009, entitled“SYSTEM AND METHOD FOR DISTRIBUTED RENDERING OF FLASH OBJECTS.” Theentire contents of the aforementioned application are herein expresslyincorporated by reference.

FIELD

The present invention is directed generally to apparatuses, methods, andsystems for rich multimedia Internet applications, and moreparticularly, to APPARATUSES, METHODS AND SYSTEMS FOR A DISTRIBUTEDOBJECT RENDERER.

BACKGROUND

Users may interact online with a variety of rich multimediaapplications. Users may contemplate sharing interesting information withtheir social networks. Various Internet visualization libraries allowfor the generation of rich multimedia Internet applications.

SUMMARY

The APPARATUSES, METHODS AND SYSTEMS FOR A DISTRIBUTED OBJECT RENDERER(“DOR”) implement distributed rendering of complex visualizations inrich multimedia objects for sharing in online social networkingapplications.

In one embodiment, a distributed rendering processor-implemented methodis disclosed, comprising: obtaining a request to render an image of avisualization included in a client application (“app”); analyzing therender request to determine data required for render processing;providing a request for the data required for render processing;obtaining the data required for render processing upon providing therequest for the required data; recreating an app state of the client appusing the obtained data required for render processing, the recreatedapp state including data related to the visualization included in theclient app; rendering the image of the visualization including in theclient app using the recreated app state; generating a publishingelement using the rendered image of the visualization included in theclient app; and providing the publishing element for publication.

In one embodiment, a rendering request processor-implemented method isdisclosed, comprising: obtaining a client app from an app database;obtaining user input from a user for the client app; obtaining dataassociated with the client app and pertaining to a member of a socialgraph of the user; generating data pertaining to a visualizationincluded in the client app based on the obtained user input and theobtained data pertaining to the member of the social graph of the user;providing a request for rendering an image of the visualization includedin the client app; providing the data pertaining to the visualizationfor processing the request for rendering the image of the visualizationincluded in the client app; and providing an indication to publish theimage of the visualization included in the client app.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying appendices and/or drawings illustrate variousnon-limiting, example, inventive aspects in accordance with the presentdisclosure:

FIG. 1 is of a block diagram illustrating various Distributed ObjectRenderer (“DOR”) components and/or affiliated entities involved indistributed rendering of visualizations in rich multimedia objects forsharing in social networking applications in some embodiments of theDOR;

FIG. 2 is of a block diagram illustrating aspects of distributedrendering of visualizations in rich multimedia objects in someembodiments of the DOR;

FIG. 3 is of a data flow diagram illustrating aspects of distributedobject rendering of visualizations in rich multimedia objects in someembodiments of the DOR;

FIGS. 4A-F are of exemplary screenshots illustrating aspects of richmultimedia object user interface features in some embodiments of theDOR;

FIG. 5 is of a logic flow diagram illustrating aspects of distributionof rich multimedia objects in some embodiments of the DOR;

FIG. 6 is of a logic flow diagram illustrating aspects of userinteraction with rich multimedia objects in some embodiments of the DOR;

FIGS. 7A-B are of logic flow diagrams illustrating aspects ofdistributed rendering of visualizations in rich multimedia objects insome embodiments of the DOR;

FIGS. 8A-B are of block diagrams illustrating aspects of distributedobject render request management in some embodiments of the DOR; and

FIG. 9 is of a block diagram illustrating embodiments of the DORcontroller.

The leading number of each reference number within the drawingsindicates the figure in which that reference number is introduced and/ordetailed. As such, a detailed discussion of reference number 101 wouldbe found and/or introduced in FIG. 1. Reference number 201 is introducedin FIG. 2, etc.

DETAILED DESCRIPTION Distributed Object Renderer (DOR)

FIG. 1 is of a block diagram illustrating various Distributed ObjectRenderer (“DOR”) components and/or affiliated entities involved indistributed rendering of visualizations in rich multimedia objects forsharing in social networking applications in some embodiments of theDOR. A variety of other compositions and arrangements of DOR componentsand/or affiliated entities may be used in alternative embodiments of theDOR as is further discussed with regard to FIG. 9.

In some implementations, the DOR may include an application (“app”)facility 100. App facility 100 may provide social networkingapplications (e.g., multi-user online games) for users 101. The usersmay interact with the app facility via a variety of clients 102. In someimplementations, the app facility may interact with the users and/orclients via a hosting server 103. For example, the hosting server 103may be included within the infrastructure of a social networking websiteproviding online social networking services for the users. In someimplementations, the hosting server 103 may provide one or moreapplication programming interfaces (“APIs”) for the app facility tointerface with the hosting server and with any users associated with thehosting server and/or social networking website for which the hostingserver provides hardware infrastructure. In some implementations, thehosting server may provide a wide variety of APIs for the app facility100. For example, the hosting server may provide APIs via which the appfacility may obtain/modify/append user profile information, user data(e.g., e-mail, text messages, blog posts, microblogs, Facebook®wallposts, tweets, status messages and/or updates), user associated mediacontent (e.g., audio/video files, etc.), RSS and/or other news feeds,social graph information pertaining to users of a social networkingservice/website hosted by the hosting server, and/or the like.

In some implementations, app facility too may include one or more appservers 104. An app server may provide one or more social networkingapplications (e.g., multi-user online games) for the users and/orclients. For example, the app server may provide a custom client-sideapplication for a client. The client-side application may execute on aclient of a user. In some implementations, the client-side applicationmay communicate and/or exchange data/media with an app server includedin the developer system to provide social networking applicationfunctionality for the user. In other implementations, a generic webbrowser, telnet, command-line and/or other applicationinterface/environment may be available on a client, and may interfacewith an app server included in the developer system. In someimplementations, an app server may utilize one or more APIs provided byhosting server to communicate with the client/user. The app server mayalso utilize the APIs provided by the hosting server toobtain/modify/append user profile information, user data (e.g., e-mail,text messages, blog posts, micro-blogs, tweets, statusmessages/updates), user associated media content (e.g., audio/videofiles, etc.), RSS and/or other news feeds, social graph informationpertaining to users of a social networking service/website hosted by thehosting server, and/or the like.

In some implementations, the app facility may include one or moredatabases, including a user profile database 105 a, and app database 105b. The app database 105 b may store one or more applications developedfor execution on the app servers and/or on clients. In someimplementations, the DOR may provide social networking applicationservices for a large number of users utilizing a wide variety of clientdevices/systems. Such client devices may be utilizing a wide variety ofoperating systems types/versions/builds/service packs, networkconnection types, connection bandwidths, display screen sizes, webbrowser environments, browser locales, language and/or otherpersonalization settings, communication interfaces and/or like clientdevice/system preferences/settings. Some client devices may obtainstandalone custom applications (e.g., from the app database via an appserver), while other client devices may utilize modern web technologies(e.g., JavaScript™, Adobe Flash®, HTML5, etc.) via a web browser toprovide social networking application services for the users.Accordingly, in some implementations, the app facility may store andmaintain a large number of code modules, code versions, applicationmodules, application versions, module/application dependency graphs,application/module specifications, compatibility lists, and/or the like,to provide social networking application services to a broad user/clientaudience. In some implementations, the applications stored in the appdatabase 104 b may be compiled from source code stored in the appdatabase. In some implementations, applications may be compiled fromsource code in the app database prior to deployment of the applicationto users and/or clients of the app facility and/or affiliated entities(e.g., social network hosted by hosting server). In alternateimplementations, source code from the app database may be compiled atruntime and/or on-the-fly during deployment to users and/or clients. Infurther implementations, instructions from source code may be read bythe app servers (e.g., line-by-line) directly from the app database andimplemented as they are read by the app servers to provide socialnetworking application services to the users and/or clients.

In implementations wherein source code from the app database is compiledprior to run time, such compilation may be performed by computingservers 106 included within the app facility.

In some implementations, an app server with which a client isinteracting may select an application stored in the app database toprovide for the client based on properties of the client (e.g., type ofclient, location, language settings, user preferences, browser locale,etc.). The app server may then obtain the application from the appdatabase and provide the app for the client. In alternateimplementations, an app server may load onto itself an application fromthe app database based on the properties of the client with which theapp server is required to interact. In some implementations, duringinteraction of an application executing on a client with an applicationexecuting on an app server, data pertaining to a user and/or client maybe generated. For example, an app server may be executing a multi-useronline gaming application in which a user using a client running aclient-side application is taking part. As part of the experienceprovided by the application executing on the client and app server, userdata (e.g., game state, user messages, user profile updates, etc.) maybe generated. In some implementations, such user data may be stored in auser profile database 105 a included within the app facility. In someimplementations, the app server may update and/or utilize data stored inthe user profile database of the app facility and/or data obtained fromthe hosting server (e.g., social networking data of the user from asocial networking website implemented on the hosting server) to providevarious social networking application abilities for the user.

In some implementations, a user utilizing an app delivered to a clientdevice via an app server may interact with the app. The app may generateand/or update data in a data structure on a client and/or server basedon the user's interaction with the app. In some implementations, theuser interaction with the app may result in a data structure includingdata representing a complex visualization (e.g., a scene in a multi-usergaming application in which the user is participating). The user maydesire to obtain an image representing a complex visualization withinthe app running on the user's client device. The user and/or clientdevice may submit a render request requesting that the app facilitygenerate an image representing the complex visualization (e.g., athumbnail). In some implementations, a number of users may beinteracting with applications provided by the app server, and maygenerate a number of such requests. In such implementations, the appfacility may store the render requests from the users in render requestqueue(s) in a queue database 105 d. In some implementations, a computingserver 106 may be monitoring the render request queues in the queuedatabase 105 d. In some implementations, the computing server, uponencountering a trigger condition, may obtain a render request from thequeue, parse the render request, determine a user associated with therender request, obtain data (e.g., a data structure associated with userand/or app) pertaining to the render request, and generate a renderedimage according to the render request based on the obtained data. Insome implementations, the app facility may provide the generatedrendered image for distribution, for example, via a social networkingapplication provided by the hosting server.

FIG. 2 is of a block diagram illustrating aspects of live reconciliationof code updates in some embodiments of the DOR. In some implementations,a user 201 may wish to utilize an application module (e.g., rendermodule 202). The user's client may issue a request (e.g., 203) to aserver to access the desired application module. In response to theuser's request, the server may provide the requested application module.The application module (e.g., render module 202) may utilize otherapplication modules (“dependent application modules”), e.g. A 210, B212, etc., to provide its designed features for the user. In someimplementations, an application module (“calling application module”),e.g., D 216, may utilize a dependent application module (e.g., C vi 215a) via an application programming interface (“API”) call (e.g., 218).

In some implementations, a software application developer maycontemplate modifications to an application module being utilized by theuser. For example, with reference to FIG. 2, the developer maycontemplate modifications to render module 202, so as to generateupdated render module 205. The developer may contemplate modificationsto an application module for a variety of reasons. For example, thedeveloper may contemplate modifications including, but not limited to,ones that enhance the range of features provided to the user/client,improve the speed/responsiveness of the application module, fix bugsidentified in prior version of code corresponding to the applicationmodule, and/or the like. The developer may input (e.g., manually enter)the contemplated modifications to the code of the module to generate anupdated code module. The developer may provide the updated code moduleto the app facility. In response, the app facility may compile theupdated code module, and generate an updated version of the applicationmodule (e.g., updated render module 205). In some implementations, anupdated version of an application module may utilize a different set ofdependent application modules than the original version of thatapplication module. For example, with reference to FIG. 2, the updatedrender module 205 and original render module 202 both may utilizeapplication module A 210. However, the updated render module 205 mayutilize application module B2 213, while the original render module 202may utilize application module B1 212 instead of application module B2213.

In some implementations, a user may be utilizing an application modulefor which the app facility has generated an updated version. In suchimplementations, the app facility may attempt to transfer the user fromthe user's version of the application module to the updated version. Forexample, the app facility may generate an instance of the updatedversion of the application module (e.g., updated render module 205), andgenerate instances of the dependent application modules (e.g., A 210, B2213) utilized by the updated version. The app facility may issue a newaccess request (e.g., 207) for the updated version of the applicationmodule on behalf of the user, and dynamically establish access for theuser to the updated version. The app facility may then delete 208 anyinstances of outdated versions (e.g., render module 202) of theapplication module and delete instances of any dependent applicationmodules (e.g., B1 212) not being utilized by the updated version of theapplication module. In some implementations, the developer system mayperform such transfer of users from one application module version toanother dynamically (e.g., 230) in real-time, while the user iscontinuously utilizing the multi-user social networking application, asdiscussed further in this disclosure.

In some implementations, a multi-user social networking application maycomprise a plurality of application modules (e.g., 202, 205, 210,212-213, 215 a-c, 216-217). An application module may be designed toexecute within a server and/or client computing environment. In someimplementations, the developer system may compile a plurality ofversions of a single application module (e.g., 215 a-c). In someimplementations, different versions 214 of the same application module(e.g., 215 a-c) may be utilized in different application scenarios. Forexample, with reference to FIG. 2, application module D 216 may utilizeversion 1 (215 a) of application module 6C. Application module E 217,however, may utilize version 3 (215 c) of application module C. Theversion of an application module utilized in an application scenario maydepend on various factors including, but not limited to: userpreferences (e.g., language, type of user experience such as normal/HDvideo, etc.), client device type, hardware installed on the client,software resources available at the client, the features that theapplication is required to provide for the user, the server computingenvironment, and/or the like.

FIG. 3 is of a data flow diagram illustrating aspects of distributedobject rendering of visualizations in rich multimedia objects in someembodiments of the DOR. In some implementations, a user 301 may interactvia a client device 302 with a hosting server 303 and/or app server 304.For example, the user may be a registered user of a social networkingand/or other sharing site (e.g., Digg™, Reddit®, Google Buzz™, Myspace®,Facebook®, Blogger™, YouTube®, and/or the like) and may interact with,e.g., a server of the social networking site (hereinafter “hostingserver”) via a smartphone. An app server 304 may configured to providean app for the social networking and/or sharing site users, and/or otherusers, via an application programming interface (“API”) provided byhosting server. In some implementations, the user 301 may provide arequest 303 a for an app to the app server (e.g., via the hostingserver). For example, a browser application executing on the clientdevice may provide, on behalf of the user, a Hypertext Transfer Protocol(“HTTP(S)”) GET message for a HyperText Markup Language (“HTML”) page,wherein the HTML page includes JavaScript™ commands to embed an Adobe®Flash object including an application for the user in the HTML page. Anexemplary HTTP(S) GET message that may be provided by a browserexecuting on the client device to request an HTML page is providedbelow:

GET /poker.html HTTP/1.1 Host: www.appserver.com User-Agent: Mozilla/4.0

In response to the app request 303 a, the hosting server and/or appserver may provide the app requested by the user and/or client. Forexample, with reference to the example browser HTTP(S) GET requestabove, the hosting server may provide an HTML page including a referenceto an Adobe® Flash object (including a user application) stored on anapp server. An exemplary HTML code listing including JavaScript™commands referencing an Adobe® Flash object within the HTML page isprovided below:

<html> <div id=“GameStage”> If you're seeing this, you don't have FlashPlayer installed. </div> <script type=“text/javascript”> var app = newSWFObject(“http://games.appserver.com/poker.swf”, “Media”, “640”, “480”,“8”, “#000000”); app.addParam(“quality”, “high”);app.write(“GameStage”); </script> </html>

Upon obtaining the app, the client device may execute the app forpresentation to the user. For example, with reference to the examplesabove, a web browser executing on the client device may render the HTMLweb page and may communicate with the app server to download the Adobe®Flash object. An Adobe® Flash browser plug-in installed on the clientdevice and operating in conjunction with the browser may play/executethe downloaded Flash object for presentation to the user. In someimplementations, the app may include interactive features, and may allowthe user to provide user input/feedback 303 d via a variety ofmechanisms (e.g., keyboard entry into a command-line interface, mouseinput in a graphical user interface, gestures on a touch-sensitiveinterface, voice commands, etc.). In some implementations, the clientdevice executing the app may generate, maintain, update and/or storedata pertaining to the user's interaction with the app (e.g., an appstate, an app data structure, a block of memory with data variables, aFlash movie clip, etc.). For example, the app may store a data structureencoded according to the JavaScript Object Notation (“JSON”) format. Anexemplary JSON-encoded data structure is provided below:

“app_data” { “app_id”: “A236269”, “app_name”: “poker”, “player_id”:“jqpublic”, “player_name”: “John Q. Public”, “gameroom_id”:“AHWJ20100630”, “md5_auth”, “f585e3efede0c3b400b25908f8fa3f6d”,“player_action”: { “timestamp”: “2010-06-30 09:23:47”, “action_type”:“raise”, “action_amount”: “50.00”, “action_source”: “credit card 1” } }

In some implementations, the app may provide data stored on the clientdevice for the hosting and/or app servers. For example, an Adobe® Flashobject may include ActionScript™ 3.0 commands to create a Secure SocketsLayer (“SSL”) connection with a server, generate a message including aJSON-encoded data structure such as illustrated in the example above,and send the message via the secure SSL connection to the server.Exemplary commands, written substantially in the form of ActionScript™3.0, to create a secure SSL connection to a server, load data from alocally stored JSON-encoded data file, and send a message including theJSON-encoded data via the SSL connection to the server, are providedbelow:

// import required packages import flash.events.*; importflash.net.socket; import flash.net.URLLoader; importflash.net.URLRequest; import com.adobe.serialization.json.*; // obtainserver socket policy file, create socket connection to server portsystem.security.loadPolicyFile(“xmlsocket://games.appserver.com:208”);msg = new socket( ); msg.connect(“https://games.appserver.com”, 255); //load data as text string from .json file var loader:URLLoader = newURLLoader( ); var request:URLRequst = new URLRequest( ); request.URL =“data.json”; loader.dataformat = “text” loader.load(request) // transmitdata to server via secure SSL connection, then close socketmsg.writeMultiByte(loader.data, “UTF-8”); msg.close( );

In some implementations, the server receiving data from the clientdevice executing the app may obtain the data, extract variables from thedata if needed, and store the data and/or variables 303 e in a userprofile database 305 a. For example, with reference to the exemplaryclient transmission of JSON-encoded data via a SSL connection providedabove, the server may be executing a Hypertext Preprocessor (“PHP”)script. The PHP script may implement a SSL socket server which listensto incoming communications on a server port to which the client devicesends the JSON-encoded data. Upon identifying an incoming communication,the PHP script may read the incoming message from the client device,parse the received JSON-encoded text data to extract information fromthe JSON-encoded text data into PHP script variables, and store the dataand/or extracted information in a relational database accessible usingthe Structured Query Language (“SQL”). An exemplary listing, writtensubstantially in the form of PHP/SQL commands, to accept JSON-encodedtext data from a client device via a SSL connection, parse the text datato extract variables, and store the data to a database, is providedbelow:

<?PHP // set ip address and port to listen to for incoming data $address= ‘192.168.0.100’; $port = 255; // create a server-side SSL socket,listen for/accept incoming communication $sock = socket_create(AF_INET,SOCK_STREAM, 0); socket_bind($sock, $address, $port) or die(‘Could notbind to address’); socket_listen($sock); $client = socket_accept($sock);// read input data from client device in 1024 byte blocks until end ofmessage do { $input = “”; $input = socket_read($client, 1024); $data .=$input; } while($input != “”); // parse data to extract variables $obj =json_decode($data, true); // store input data in a user profilesdatabase mysql_connect(″201.408.185.132″,$DBserver,$password); // accessdatabase server mysql_select(″UserProfile.SQL″); // select database toappend mysql_query(“INSERT INTO ProfilesTable (transmission) VALUES($data)”); // add data to ProfilesTable table in UserProfile databasemysql_close(″UserProfile.SQL″); // close connection to database ?>In some implementations, the user and/or client device may provide arender request 303 f including data such as those discussed above forthe hosting and/or app servers. For example, an Adobe® Flash object mayinclude ActionScript™ 3.0 commands to generate a HTTP POST messageincluding information such as, but not limited to, an Internet Protocol(“IP”) address of the requesting client device, a name of the objectincluding the visualization to be rendered, information on quality of animage to be rendered (e.g., image quality, image height/width in pixels,image format, etc.), and an indication of an action to perform on therendered image (e.g., e-mail to specific e-mail address(es), post on,e.g., a Facebook® profile page/wall, store on server, etc.), and/or thelike. Exemplary ActionScript™3.0 commands to generate and send a renderrequest message, including render details encoded in JSON format, areprovided below:

// import required packages import.com.adobe.serialization.json.JSON;import flash.events.Event; import flash.net.URLLoader; importflash.net.URLRequest; import flash.net.URLRequestMethod; importflash.net.URLvariables; // generate message body (in JSON format) vardat: Array = new Array( ); dat.push({field_name: “ip_address”, value:“78.213.89.93”}); dat.push({field_name: “object_name”, value:“pokerapp.swf”}); dat.push({field_name: “img_format”, value: “jpeg”});dat.push({field_name: “img_max_dim”, value: “90”});dat.push({field_name: “img_quality”, value: “85”}); var msg:URLVariables = new URLVariables( ); msg.data = JSON.encode(dat); // setup HTTP POST message details var req: URLRequest = new URLRequest( );req.method = URLRequestMethod.POST; req.data = msg; req.url =“www.appserver.com/renderrequest.php”; // send HTTP POST message toserver ldr.addEventListener(Event.COMPLETE, handleServerResponse);ldr.load(req);

The server obtaining the render request message from the client devicemay parse the body of the render request message, extract theinformation to the render request, and store 303 g the informationpertaining to the render request in a queue database 305 d. For example,with reference to the example above, a PHP script executing on theserver may obtain the HTTP(S) POST message, parse the JSON-encodedmessage body, extract the information into PHP variables, and store thedetails of the render request to a database using PHP/SQL commands. Anexemplary listing, written substantially in the form of PHP/SQLcommands, to parse and extract JSON-encoded data from a message sentfrom a client device, and store the data to a queue database, isprovided below:

<?PHP // parse data in $dat to extract data into array $obj =json_decode($dat, true); // store extracted array data in a renderrequest queue databasemysql_connect(″201.408.185.132″,$DBserver,$password); // access databaseserver mysql_select(″RenderRequest.SQL″); // select database to appendmysql_query(“INSERT INTO RequestTable (timestamp, ip, app, format, dim,quality) VALUES (time( ), $obj[“ip_address”], $obj[“object_name”],$obj[“img_format”], (int)$obj[“img_max_dim”],(int)$obj[“img_quality”])”); // add data to Request table inRenderRequest database mysql_close(″RenderRequest.SQL″); // closeconnection to database ?>

In some implementations, a computing server 306, app server 304 and/orhosting server 303 may monitor the number of requests stored in thequeue database 305 d. In some implementations, a server may triggerprocessing of the render requests based on monitoring the queuedatabase. For example, the server may trigger render request processingupon the number of pending render requests reaching a threshold value.In some implementations, each render request stored in the queuedatabase may have a priority value associated with it. In someimplementations, the server may monitor the priority values, and a timeelapsed since the render request was stored in the queue database, andtrigger the processing of the render request based on its priority valueand the time elapsed since the request was stored in the queue database.The priority value may be determined in various implementations bynumerous factors, including, but not limited to, the IP address of theclient device submitting the request, a time elapsed since the requestwas stored in the queue database, details of the render request (e.g.,name of the app including the visualization to be rendered), a user IDof the user submitting the render request, characteristics of a socialgraph of the user submitting the render request (e.g., number of socialnetwork friends, number of social gaming friends for a gaming app, depthof the user's social graph), an amount of time the user has spent usingthe app that includes the visualization, a frequency with which thevisualization has occurred within the app when used by the user, afrequency of social activity of the user (e.g., such as Facebook®profile/wall postings, blogging, Twitter™ tweets of the user, etc.)and/or the like. In some implementations, upon determining that therender request needs to be processed, the computing sever 306 may obtainuser profile data 303 i (e.g., in-use data provided by the user/clientwhile the user is using the app) from the user profile database 305 a,and/or data from the user's client device 302. For example, thecomputing server may obtain a listing of all the user interactions withthe app, and may recreate the state of the app executing on the user'sclient device by sequentially providing inputs into a copy of the appexecuting on the computing server matching the inputs provided by theuser to the app executing on the user's client device.

In other implementations, the computing server may provide aninstruction to the user's client device to freeze the state of the app,and provide the app and/or data structures stored on the user's clientdevice related to the app. For example, in some implementations, theclient device may have stored thereon a data structure representative ofa scalable vector illustration, e.g., a Scalable Vector Graphics (“SVG”)data file. The data structure may include, for example, datarepresenting a vector illustration. For example, the data structure maydescribe a scalable vector illustration having one or more objects inthe illustration. Each object may be comprised of one or more pathsprescribing, e.g., the boundaries of the object. Further, each path maybe comprised of one or more line segments. For example, a number of verysmall line segments may be combined end-to-end to describe a curvedpath. A plurality of such paths, for example, may be combined in orderto form a closed or open object. Each of the line segments in the vectorillustration may have start and/or end anchor points with discreteposition coordinates for each point. Further, each of the anchor pointsmay comprise one or more control handles. For example, the controlhandles may describe the slope of a line segment terminating at theanchor point. Further, objects in a vector illustration represented bythe data structure stored on the client device may have stroke and/orfill properties specifying patterns to be used for outlining and/orfilling the object. Further information stored in the data structure mayinclude, but not be limited to: motion paths for objects, paths, linesegments, anchor points, etc. in the illustration (e.g., for animations,games, video, etc.), groupings of objects, composite paths for objects,layering information (e.g., which objects are on top, and which objectsappear as if underneath other objects, etc.) and/or the like. Forexample, the data structure stored on the user's client and includingdata on the scalabale vector illustration may be encoded according tothe open XML-based Scalable Vector Graphics “SVG” standard developed bythe World Wide Web Consortium (“W3C”). An exemplary XML-encoded SVG datafile, written substantially according to the W3C SVG standard, andincluding data for a vector illustration comprising a circle, an openpath, a closed polyline composed of a plurality of line segments, and apolygon, is provided below:

<?XML version = “1.0” standalone = “no”> <!DOCTYPE svg PUBLIC″-//W3C//DTD SVG 1.1//EN″″http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd″> <svg width = “100%”height = “100%” version = “1.1” xmlns=″http://www.w3.org/2000/svg″><circle cx=″250″ cy=″75″ r=″33″ stroke=″blue″ stroke-width=″2″fill=″yellow″/> <path d=″M250 150 L150 350 L350 350 Z″ /> <polylinepoints=″0,0 0,20 20,20 20,40 40,40 40,80″style=″fill:white;stroke:green;stroke-width:2″/> <polygon points=″280,75300,210 170,275″ style=″fill:#cc5500; stroke:#ee00ee;stroke-width:1″/></svg>

The client device may provide the XML-encoded SVG data via one or moreHTTP(S) POST messages and/or using an SSL connection to the server, asillustrated in examples provided above in this disclosure with regardto, e.g., generating and sending a render request message. In someimplementations, using the data obtained from the user profile database305 a and/or client device 302, the computing server may recreate an appstate identical to the app state on the client device. The app state mayinclude the complex visualization (or visualization similar to thecomplex visualization) for which the user originally submitted therender request. Upon recreating an app state identical or similar tothat on the client device, the computing server may process the renderrequest associated with the obtained app and/or data by rendering thecomplex visualization recreated within the app executing on thecomputing server. The computing server may obtain the rendered image asa render result 303 j, and may provide the render result for storageand/or further action to other computing, app and/or hosting servers.For example, the computing server may host an Adobe® Flash objectincluding ActionScript™ 3.0 commands to render the visualizationincluded in the app, and provide the rendered visualization for aprocess on the same computing server and/or other server/client.Exemplary commands, written substantially in a form adapted toActionScript™ 3.0, for rendering a visualization of a scene within anAdobe® Flash object, scaling the image to appropriate dimensions,encoding the image in a predetermined format and with specified imagequality, and providing the image to a remotely executing PHP script forstorage and/or other actions are provided below:

// import necessary modules/functions import flash.display.BitmapData;import flash.geom.*; import com.adobe.images.JPGEncoder; // generateempty thumbnail bitmap with appropriate dimensions varbitSource:BitmapData = new BitmapData (sketch_mc.width,sketch_mc.height); // capture snapsot of movie clip in bitmapbitSource.draw(sketch_mc); var imgSource:Image = new Image( );imgSource.load(new Bitmap(bitSource, “auto”, true)); // generate scalingconstants to generate thumbnail with 90 pixels maximum dimension varres:Number = 90 / max(sketch_mc.width, sketch_mc.height); varwidth:Number = round(sketch_mc.width * res); var height:Number =round(sketch_mc.height * res); // scale the imageimgSource.content.width = width; // JPEG-encode bitmap for passing toPHP script, 85% JPEG compression image quality var jpgEncoder:JPGEncoder= new JPGEncoder(85); var jpgStream:ByteArray =jpgEncoder.encode(jpgSource); // Pass JPEG-encoded bitmap to PHP scriptvar header:URLRequestHeader = new URLRequestHeader(″Content-type″,“application/octet-stream”); var jpgURLRequest:URLRequest = newURLRequest(“jpg_encoder_download.php?name=sketch.jpg”);jpgURLRequest.requestHeaders.push(header); jpgURLRequest.method =URLRequestMethod.POST; jpgURLRequest.data = jpgStream;navigateToURL(jpgURLRequest, “_blank”);

In some implementations, the server obtaining the render result 303 jmay generate a message 303 k (e.g., newsfeed, Facebook® wall posting,blog posting, e-mail message, multimedia messaging service “MMS”message, etc.) including the render result 303 j, and may provide themessage 303 k for an app server, hosting server, client device and/oruser. For example, a server may be executing a PHP script includingcommands to post the render result image to a wall of, e.g., a Facebook®user. An exemplary listing, written substantially in the form of PHPcommands, for posting a render result image to the wall of a Facebook®user is provided below:

<?PHP // save image stored in $img_src variable to file ‘thumbnail.jpg’on server $success = imagejpeg($img_src, ‘thumbnail.jpg’); // generateone-time session for Facebook ® access $fb = newFacebookRestClient($fb_apikey, $fb_secret); $result = $fb −>call_method(‘facebook.auth.getSession’,array (′auth_token′ =>$one_time_token, ′generate_session_secret′ => true)); $session_key =$result[‘session_key’];require_once(‘facebook-platform/php/facebook.php’); $facebook −> newFacebook($fb_apikey, $fb_secret); $facebook −> api_client −> session_key= $session_key; // select user on whose wall post message $fetch =array(′friends′ => array(′pattern′ => ′.*′, ′query′ => ″select uid2 fromfriend where uid1={$user}″)); $facebook −> api_client −>admin_setAppProperties(array(‘preload_fq1’ => json_encode($fetch))); //prepare post message $message = [‘Check out’ $user ‘’s cool pokerhand!’]; $attachment = array(‘media’ => array(array(‘type’ => ‘image’,‘src’ => $img_src, ‘href’ => $img_href))); $attachment =json_encode($attachment); // post message $facebook −> api_client_stream−> stream_publish($message, $attachment); ?>

FIGS. 4A-F are of exemplary screenshots illustrating aspects of richmultimedia object user interface features in some embodiments of theDOR. In some implementations, the user may desire to have rendered(e.g., for posting on a blog, social network profile, etc.) avisualization included in the app executing on the client device. Insome implementations, the app may include one or more render requestsubmission features. For example, the app may provide user interfacefeatures designed to facilitate user submission of render requests. Suchrender request submission features may, in some implementations, betriggered based on various events including, but not limited to: userachieving a high score, user completing a stage in a game, userachieving an unusual result, the user activating a user interfaceelement to create a render request, and/or the like. In someimplementations, a client application 400 may include a visualization401 (e.g., computed with reduced quality by the client device). Theclient application may provide the user an option to submit a renderrequest for rendering a high-quality image, video, etc. of thevisualization included in the client app. For example, the clientapplication may be configured so that an options menu (e.g., 402)appears for the user when the user provides an appropriate input (e.g.,user right-clicks within the client app). In some implementations, theoptions menu may include an option to generate a render request (e.g.,“Render This Scene” 203). The client application may be configured sothat the user can select the option, e.g., via a keyboard entry, mouseclick, finger gap, touch gesture, etc. In response to the user selectingthe option to generate the render request, the client application mayprovide a user interface (“UI”), e.g., 404, including one or more userinterface features (e.g., 404,a-g, 407 a-g) to generate and submit arender request. For example, the client application may include UIfeatures to select a format for a rendered image (e.g., dropdown listbox 404 a), select an image quality (e.g., dropdown list box 404 b);select an image size (e.g., dropdown list box 404 c) and/or the like.The UI may include, for example, a text field (e.g., 404 d) where theuser can enter a note to be attached (e.g., as metadata) to the renderedimage. The UI may include a plurality of submission UI elements (e.g.,submit buttons 404 e-g) that the user may activate upon entering therequired render request information into the UI, In response to the useractivating one or more of the submission UI elements, the clientapplication may submit render requests to publications associated withthe user-activated submission UI elements (e.g., Facebook®, Digg™,Reddit®, Google Buzz™, Myspace®, Blogger®, YouTube®, and/or the like).In some implementations, the client app may have stored the user logincredentials for each of the publications that are associated with the UIsubmission elements. In such implementations, the client application mayutilize the stored login credentials to obtain access to securedpublications, and then submit the user-provided render requests to thepublications.

In some implementations, the client app may allow the user to select aportion of the visualization for render request submission. For example,the client app may be configured so that the user can click (e.g., 405)a mouse input device at a point within the visualization, drag the mousepointer for the mouse, and release the mouse pointer at a desiredlocation. In response, the client app may determine a closed boundary(e.g., 406) within the visualization using the points at which the mousewas clicked and/or released (“boundary anchor points”). The client appmay provide the coordinates of the boundary anchor points as part of therender request. The server processing the render request may thengenerate a visualization of the user-selected portion of thevisualization included in the client app. In some implementations, theclient app may provide the user with a UI for submission of videorendering requests (e.g. 407). Such a UI may include UI elements (e.g.,407 a-d) for the user to enter file format (e.g., 407 a) for movies,animations, etc., video length (e.g., 407 b), video quality (e.g., 407c), and/or the like. The UI may provide elements (e.g., 407 d) where theuser may enter information about the video (e.g., to be stored asmetadata in the video file).

Upon providing the require video render request information, the usermay activate one or more submission UI elements (e.g., submit buttons407 e-g) to indicate that the app facility should submit the renderedvideo to publications associated with the UI submission elements. Theclient app may also provide the user with the option to select (e.g.,408) a region within the visualization (e.g., 409) to submit for videorendering.

In some implementations, upon obtaining the user's activating asubmission UI element, the client application may determine whetheradditional information is required, and request the information from theuser if necessary. For example, the client application, may provide oneor more dialog boxes (e.g., 410) requesting additional informationbefore render request submission to a server. For example, the clientapplication may request the user to provide (e.g., 411) a user nameand/or ID for e.g., a target user social networking profile page, blog,webpage, etc. to which the rendered results may be posted by the server.The client application may also request the user to provide anindication (e.g., 412) of a template according to which the servershould format the render results for posting. The client application mayalso provide the user with one or more elements (e.g., 413, ‘Add anote’, 409, etc.) using which the user may provide a note, message,comment, etc. to attach with the render results for posting by theserver. Upon providing the necessary information, the user may confirmthe render request by activating an element (e.g., 414) provided by theclient application. The client application may then submit theuser-provided render request and associated details to the server, e.g.,via a HTTP(S) POST message as discussed above with reference to FIG. 3.Upon obtaining the render request, the server may process the renderrequest and generate a render result (e.g., hyperlinked thumbnail 418,high-quality rendered image/video 419, etc.), as discussed above withreference to FIG. 3. The server may use the user-provided target userinformation (e.g., user-selected format template, user notes, comments,messages, etc.) to generate a publishing element (e.g., 417-418) usingthe render result and the user-provided information. The server maypublish the publishing element to a site (e.g., 415) for the target user(e.g., 416), for example using PHP commands such a those presented abovein the discussion of FIG. 3. The server may also attach theuser-provided information (e.g., user entries into 404 d, 407 d, 413,etc.) as part of the publishing element (e.g., 417, 420).

FIG. 5 is of a logic flow diagram illustrating aspects of distributionof rich multimedia objects in some embodiments of the DOR, e.g., aclient initialization component. In some implementations, a user and/orclient may provide a request 502 for an app for a hosting and/or appserver. For example, a web browser executing on the client may provide aHTTP(S) GET message requesting a HTML page including JavaScript™commands to embed an Adobe® Flash object including the application forthe user in the HTML page, as illustrated in the example provided withreference to FIG. 3. The server receiving 503 the app request maydetermine (e.g., 504, option ‘Yes’) that that the user be authenticatedin order to use the app, and request user 4 credentials 505 from theuser. For example, in some implementations, the server may provide anHTML page with an input form for the user to provide user credentials,and request 505 user credentials. The user may input the usercredentials (e.g., 506) into the HTML input form, and press a submitbutton included in the HTML form. Upon pressing the submit button, theweb browser of the client device may generate a HTTP(S) POST messageincluding the user-provided form inputs for the server. As anotherexample, in some implementations, the server may provide an Adobe® Flashobject including ActionScript™ 3.0 commands to request (e.g., 505) theuser to provide user credentials (e.g., 506) by entering the credentialsinto input text fields included in the Adobe® Flash object, and mayprovide the user-entered credentials for a server via a HTTP(S) POSTmessage to the server. Exemplary ActionScript™ 3.0 commands forproviding a HTTP(S) POST message are provided below:

// generate HTTP GET message with username, password and applicationname var dataOut:LoadVars = new LoadVars( ); function checkUser( ):Void{ dataOut.username = username.text; dataOut.password = password.text;dataOut.appname = “poker”; dataOut.send(“authenticate.php”, “newwin”,“GET”); } // send HTTP GET message on ‘checkUser’ button mouse clickenterbtn.addEventListener(“click”, checkUser);

Upon obtaining the user credentials, the server may query a user profiledatabase to determine whether the user is authenticated (e.g., 507) touse the app. For example, the server may implement a PHP scriptincluding commands to query a user profile database for userauthentication details, and may compare the authentication detailsobtained via querying the database with the user-entered credentials.Exemplary PHP commands to query a user profile database to determinewhether a user is authentication to use an app are provided below:

function authenticate($DBserver, $pgmid, $pgmpass, $userid, $userpass,$appname) { mysql_connect($DBserver, $pgmid, $pgmpass); // PHP scriptaccesses database server mysql_select_db(″UserProfile.SQL″); // selectdatabase to search $query = ″SELECT URL FROM ProfilesTable WHERE useridLIKE ′%′ $userid AND password LIKE ′%′ $userpass AND appname LIKE ′%′$appname; // create query for user permissions and game URL in theProfilesTable table with ‘userid’ and ‘userpass’ as search terms$gameURL = mysql_query($query); // query for user existence andpermissions return $gameURL; }

In some implementations, if the user is authenticated (e.g., 507, optionYes), the server may query an app database for an app to provide for theuser, based on the details of the user's app request. If the app is notavailable (e.g., 510, option No), the server may generate an errormessage (e.g., 511) for the user, and may provide an alternate resourceand/or method for the user to obtain an app. If the app is available,the server may provide the app for the user to the client device, usinge.g., an IP address for the client device included in the app requestmessage originally provided by the user. The client, upon obtaining theapp may execute/display 513 the app for the user. For example, theclient may obtain a Shockwave Flash (*.swf) object from the server, andmay invoke an Adobe® Flash web browser pug-in to process and display the*.swf object for the user.

FIG. 6 is of a logic flow diagram illustrating aspects of userinteraction with rich multimedia objects in some embodiments of the DOR,e.g., a client transaction component. In some implementations, the appmay include interactive features for the user. For example, the app maybe configured to accept user input/feedback via a variety of mechanismsincluding, but not limited to, keyboard entry, mouse input, touch input,touch gestures, voice commands, auto-form filling, and/or the like. Theapp may provide a variety of user interfaces configured to accept suchinput from the user including, but not limited to, command line keyboardentry interfaces, graphical user interfaces, touch-sensitive interfaces,and/or the like. In some implementations, the user may interact 602 withthe app and provide input into the app. For example, the user mayprovide input as part of a gaming application, a social application(e.g., chat room, instant messaging, etc.), information resourceselection, and/or the like. The client device may detect input from theuser 603. For example, the client may include hardware resources (e.g.,keyboard, mouse, etc.) that provide triggers when a user manipulates theinput hardware resources. Upon detecting user input (e.g., 603, optionYes), the client may obtain such user input 605, and determine whetherthe provided input is sufficient for the action and/or circumstanceswithin the app at the time of user input. For example, the app may beconfigured to only accept user credentials input if the user credentialinput is longer than a predetermined number of characters. If the inputis determined to be insufficient (e.g., 606, option No), the client mayindicate 607 to the user to provide further input, and may wait 604 forthe requested user input to be provided. If the input is determined tobe sufficient (e.g., 606, option Yes) for the app to complete the actionfor which it requested/is provided the input, the app may incorporatethe input into the interactive user experience, and proceed withinstructions execution according to the satisfactory user input (e.g.,608). In some implementations, the client executing the app maygenerate, maintain, update and/or store data pertaining to the user'sinteraction with the app (e.g., an app state, an app data structure, ablock of memory with data variables, a Flash movie clip, etc.). Forexample, the app may store an XML data file including vectorillustrations encoded according to the W3C SVG standard, such as thedata structure illustrated in the example provided with reference toFIG. 3. In some implementations, the client may determine whether toprovide data stored on the client for a server 609. If the clientdetermines that data should be provided for the server (e.g., 609,option Yes), the client may prepare the data for transmission andprovide the data for the server 610, for example, via a HTTP(S) POSTmessage and/or secure SSL connection with the server as discussedpreviously. The server may obtain 611 the data provided by the client,and may store the data in a user profile database. For example, theserver may utilize PHP/SQL commands to obtain the data provided by theclient, extract information variables from the provided data, connect toa database, and store the data and/or extracted information variables inthe database for later use. In some implementations, the user mayinteract with the app executing on the client in a continuous manner,and the client may continuously transmit user data to a server forstorage in a database and/or further processing.

FIGS. 7A-B are of logic flow diagrams illustrating inventive aspects ofdistributed rendering of visualizations in rich multimedia objects insome embodiments of the DOR, e.g., a render request processingcomponent. In some implementations, generation of a request forrendering of a visualization included in an app being used by a user ona client may be triggered. The render request generation may betriggered in various implementations in a number of ways. For example,the user may desire and request generation of a rendered image, theclient, via the app, may initiate render request generation upon theuser reaching a milestone within the app (e.g., user achieving a highgame score, user using the app for a predetermined length oftime/longest amount of time, etc.), and/or a computing, app and/orhosting server may initiate the trigger for render request generation,e.g., based on analyzing user data stored in the user profile database.Upon detecting a trigger (e.g., 703, option Yes) from the trigger sourcefor render request generation, the server may generate 705 a renderrequest record, and store the render request in a queue database. Theapp facility may continue to detect, analyze, and accept render requesttriggers from users, clients, servers and/or other entities affiliatedwith the app facility. For example, as illustrated in examples providedpreviously with regard to FIG. 3, a server may execute a PHP/SQL commandset configured to obtain a HTTP(S) POST message from a client and/orother affiliated entity, parse the message to extract render requestdetails, and store the extracted render request details in a database.

In some implementations, the server may determine that a render requestneeds to be processed, and may initiate processing of the renderrequest. For example, the server may monitor the number of requestsstored in the queue database and may trigger processing of the renderrequest based on monitoring the queue database. In some implementations,the server may calculate priority values for the pending renderrequests, and select/obtain the render request (e.g., 707) with thehighest priority for processing. For example, the server may calculatepriority values and select a render request for processing as describedfurther below with reference to FIG. 7. The server may obtain thedetails of the render request 708 (e.g., IP address of the client, userID of the user, app name, time of submission of the render request,etc.) by querying the queue database for the record of the renderrequest selected for processing, and analyzing the obtained record todetermine the render process requirements 708 (e.g., Adobe® Flash objectto render, app to obtain from the app database, where to report theresults of render processing, etc.). The server may generate queries tothe user profile database for the data required to process the renderrequest. For example, the server may request a record of all user inputthat was provided to the app by the user from the user profile database.In such an example, in some implementations, the server may recreate thestate of the app on the user's client by sequentially providing the userinput as obtained from the user profile database. In otherimplementations, the server may determine that the state of the app onthe user's client resulted from other inputs besides that available inthe user profile database (e.g., 711, option No). For example, the usermay be using a massively multiplayer online game app, and the server maydetermine that the visualization included in the app executing on theuser's client may not be recreated using only the data available in theuser profile database. In such implementations, the server may generatea request 712 for the user/client to provide the data pertaining to theapp stored in the client for the server to process the render request.For example, the server may provide a HTTP(S) GET message to the clientusing the IP address of the client obtained from the record of therender request, and request a data structure associated with the appusing the HTTP(S) GET message. Upon obtaining the data request 713 fromthe server, the user and/or client may, in some implementations, freezeall activity pertaining to the app on the client. The client may obtaina snapshot 714 of the data structure associated with the app, andprovide 715 the data structure for the server. For example, a webbrowser (and/or app including ActionScript™ 3.0 commands) executing onthe client may obtain the HTTP(S) GET message (of the example above),process the GET message, and provide the data stored on the client asrequested by the server in the form of a HTTP(S) POST message to theserver based on the HTTP GET(S) message provided by the server. Forexample, the client may utilize commands similar to the examplesprovided illustrating such messaging abilities with reference to FIG. 3.In some implementations, upon obtaining the data required for processingthe render request (e.g., 716), the server may generate the renderedimage 717 according to the details of the render request obtained fromthe queue database. For example, the server may be executingActionScript™ 3.0 commands included in an Adobe® Flash object stored onthe server. The server may also be executing a PHP script includingcommands to communicate with external computing/database systems(clients, servers, hosting servers for message postings, etc.) and/orthe local file storage system of the server. The PHP script may beconfigured to obtain data from the databases, users, clients and/orother affiliated entities, as illustrated in the examples of HTTP(S)POST messaging and secure SSL communication provided previously withreference to FIG. 3. Further, the ActionScript™ 3.0 commands may, forexample, be configured to obtain variables from the PHP script.Exemplary commands to obtain variables from a PHP script, writtensubstantially in the form of ActionScript™ 3.0, are provided below:

import flash.events.*; import flash.net.*; // Prepare request varrequest:URLRequest = new URLRequest(″\localhost\communicator.php″);request.method = URLRequestMethod.GET; var loader:URLLoader = newURLLoader( ); loader.dataFormat = URLLoaderDataFormat.VARIABLES;loader.addEventListener(Event.COMPLETE, completeHandler);loader.load(request);

The server may render the image 717 according to the render requestbased on the data obtained from the user, client and/or user profiledatabase. For example, the server may utilize ActionScript™ 3.0 commandssimilar to those discussed in the example provided previously withreference to FIG. 3. Upon rendering the image, the server may query adatabase for a publishing template 718 to report the results of therender processing. For example, the server may obtain a template stringfor posting the render results on, e.g., a wall of a Facebook® user. Theserver may generate a publishing element (e.g., newsfeed, Facebook®wall/profile posting, blog posting, e-mail message) using the renderedimage 719, and provide the publishing element to the publisher 720. Forexample, the server may attach the rendered image to a message forposting on a sharing site (e.g, a Facebook®, Digg™, Reddit®, GoogleBuzz™, Myspace®, Blogger™, YouTube®, and/or the like) using PHP commandssuch as the exemplary commands provided above with reference to FIG. 3.

FIGS. 8A-B are of block diagrams illustrating aspects of distributedobject render request management in some embodiments of the DOR, e.g., arequest management component. In some implementations, the computingserver may select the next render request to be processed according to apriority queuing process. In some implementations, the computing servermay determine the next render request to process based on the order(e.g., using a timestamp submitted with each render request) in whichthe render requests entered the render request queue and a priorityvalue assigned to each of the render requests (e.g., based on anoriginating IP address associated with each render request). Each renderrequest in a queue may be assigned a queue number indicative of theorder in which the render requests entered the queue and a priorityvalue indicative of the importance attached to processing the renderrequest. In some implementations, the computing server may determine therender request priority values based on a number of factors including,but not limited to, render request ID, originator ID, and/or the like.In some implementations, the computing server may assign relativeimportance to the order in which render requests entered the queue andthe priority value assigned to any particular render requests usingposition weights and/or priority weights. For example, a net priorityvalue of a render request in a queue may be determined by the computingserver as the weighted sum of the queue position and the render requestpriority, wherein the weights are the position weight and the priorityweight, as illustrated in FIG. 8A:

Net Render Request Priority Value = Request Queue Position * PositionWeight + Request Priority * Priority Weight;

In such implementations, the render request next selected for processingby the computing server may be identified as the render request havingthe highest net render request priority value. In furtherimplementations, the computing server may utilize multiple queues forrender requests, such as the non-limiting exemplary illustration in FIG.8B. In some implementations, each queue may be assigned a queue priorityweight relative to the other queues for render requests. In suchimplementations, the net priority value of a render request may beweighted by the weight assigned to its render request queue:

Net Render Request Priority Value = (Request Queue Position * PositionWeight + Request Priority * Priority Weight) * Queue Priority Weight;

In some such implementations, the next render request selected by thecomputing server for processing among the render requests in all thequeues may be the render request having the highest net render requestpriority value, including the weighting assigned to each of the renderqueues in the queue database.

DOR Controller

FIG. 9 illustrates inventive aspects of a DOR controller 901 in a blockdiagram. In this embodiment, the DOR controller 901 may serve toaggregate, process, store, search, serve, identify, instruct, generate,match, and/or facilitate interactions with a computer through enterpriseand human resource management technologies, and/or other related data.

Typically, users, which may be people and/or other systems, may engageinformation technology systems (e.g., computers) to facilitateinformation processing. In turn, computers employ processors to processinformation; such processors 903 may be referred to as centralprocessing units (CPU). One form of processor is referred to as amicroprocessor. CPUs use communicative circuits to pass binary encodedsignals acting as instructions to enable various operations. Theseinstructions may be operational and/or data instructions containingand/or referencing other instructions and data in various processoraccessible and operable areas of memory 929 (e.g., registers, cachememory, random access memory, etc.). Such communicative instructions maybe stored and/or transmitted in batches (e.g., batches of instructions)as programs and/or data components to facilitate desired operations.These stored instruction codes, e.g., programs, may engage the CPUcircuit components and other motherboard and/or system components toperform desired operations. One type of program is a computer operatingsystem, which, may be executed by CPU on a computer; the operatingsystem enables and facilitates users to access and operate computerinformation technology and resources. Some resources that may beemployed in information technology systems include: input and outputmechanisms through which data may pass into and out of a computer;memory storage into which data may be saved; and processors by whichinformation may be processed. These information technology systems maybe used to collect data for later retrieval, analysis, and manipulation,which may be facilitated through a database program. These informationtechnology systems provide interfaces that allow users to access andoperate various system components.

In one embodiment, the DOR controller 901 may be connected to and/orcommunicate with entities such as, but not limited to: one or more usersfrom user client devices 911; peripheral devices 912; an optionalcryptographic processor device 928; and/or a communications network 913.For example, the DOR controller 801 may be connected to and/orcommunicate with users operating client device(s) including, but notlimited to, personal computer(s), server(s) and/or various mobiledevice(s) including, but not limited to, cellular telephone(s),smartphone(s) (e.g., iPhone®, Blackberry®, Android OS-based phonesetc.), tablet computer(s) (e.g., Apple iPad™, HP Slate™ etc.), eBookreader(s) (e.g., Amazon Kindle™ etc.), laptop computer(s), notebook(s),netbook(s), gaming console(s) (e.g., Nintendo® DS etc.), portablescanner(s) and/or the like.

Networks are commonly thought to comprise the interconnection andinteroperation of clients, servers, and intermediary nodes in a graphtopology. It should be noted that the term “server” as used throughoutthis application refers generally to a computer, other device, program,or combination thereof that processes and responds to the requests ofremote users across a communications network. Servers serve theirinformation to requesting “clients.” The term “client” as used hereinrefers generally to a computer, program, other device, user and/orcombination thereof that is capable of processing and making requestsand obtaining and processing any responses from servers across acommunications network. A computer, other device, program, orcombination thereof that facilitates, processes information andrequests, and/or furthers the passage of information from a source userto a destination user is commonly referred to as a “node.” Networks aregenerally thought to facilitate the transfer of information from sourcepoints to destinations. A node specifically tasked with furthering thepassage of information from a source to a destination is commonly calleda “router.” There are many forms of networks such as Local Area Networks(LANs), Pico networks, Wide Area Networks (WANs), Wireless Networks(WLANs), etc. For example, the Internet is generally accepted as beingan interconnection of a multitude of networks whereby remote clients andservers may access and interoperate with one another.

The DOR controller 901 may be based on computer systems that maycomprise, but are not limited to, components such as: a computersystemization 902 connected to memory 929.

Computer Systemization

A computer systemization 902 may comprise a clock 930, centralprocessing unit (“CPU(s)” and/or “processor(s)” (these terms are usedinterchangeable throughout the disclosure unless noted to the contrary))903, a memory 929 (e.g., a read only memory (ROM) 906, a random accessmemory (RAM) 905, etc.), and/or an interface bus 907, and mostfrequently, although not necessarily, are all interconnected and/orcommunicating through a system bus 904 on one or more (mother)board(s)902 having conductive and/or otherwise transportive circuit pathwaysthrough which instructions (e.g., binary encoded signals) may travel toeffect communications, operations, storage, etc. Optionally, thecomputer systemization may be connected to an internal power source 986.Optionally, a cryptographic processor 926 may be connected to the systembus. The system clock typically has a crystal oscillator and generates abase signal through the computer systemization's circuit pathways. Theclock is typically coupled to the system bus and various clockmultipliers that will increase or decrease the base operating frequencyfor other components interconnected in the computer systemization. Theclock and various components in a computer systemization drive signalsembodying information throughout the system. Such transmission andreception of instructions embodying information throughout a computersystemization may be commonly referred to as communications. Thesecommunicative instructions may further be transmitted, received, and thecause of return and/or reply communications beyond the instant computersystemization to: communications networks, input devices, other computersystemizations, peripheral devices, and/or the like. Of course, any ofthe above components may be connected directly to one another, connectedto the CPU, and/or organized in numerous variations employed asexemplified by various computer systems.

The CPU comprises at least one high-speed data processor adequate toexecute program components for executing user and/or system-generatedrequests. Often, the processors themselves will incorporate variousspecialized processing units, such as, but not limited to: integratedsystem (bus) controllers, memory management control units, floatingpoint units, and even specialized processing sub-units like graphicsprocessing units, digital signal processing units, and/or the like.Additionally, processors may include internal fast access addressablememory, and be capable of mapping and addressing memory 529 beyond theprocessor itself; internal memory may include, but is not limited to:fast registers, various levels of cache memory (e.g., level 1, 2, 3,etc.), RAM, etc. The processor may access this memory through the use ofa memory address space that is accessible via instruction address, whichthe processor can construct and decode allowing it to access a circuitpath to a specific memory address space having a memory state. The CPUmay be a microprocessor such as: AMD's Athlon, Duron and/or Opteron;ARM's application, embedded and secure processors; IBM and/or Motorola'sDragonBall and PowerPC; IBM's and Sony's Cell processor; Intel'sCeleron, Core (2) Duo, Itanium, Pentium, Xeon, and/or XScale; and/or thelike processor(s). The CPU interacts with memory through instructionpassing through conductive and/or transportive conduits (e.g., (printed)electronic and/or optic circuits) to execute stored instructions (i.e.,program code) according to conventional data processing techniques. Suchinstruction passing facilitates communication within the DOR controllerand beyond through various interfaces. Should processing requirementsdictate a greater amount speed and/or capacity, distributed processors(e.g., Distributed DOR), mainframe, multi-core, parallel, and/orsuper-computer architectures may similarly be employed. Alternatively,should deployment requirements dictate greater portability, smallerPersonal Digital Assistants (PDAs) may be employed.

Depending on the particular implementation, features of the DOR may beachieved by implementing a microcontroller such as CAST's R8051XC2microcontroller; Intel's MCS 51 (i.e., 8051 microcontroller); and/or thelike. Also, to implement certain features of the DOR, some featureimplementations may rely on embedded components, such as:Application-Specific Integrated Circuit (“ASIC”), Digital SignalProcessing (“DSP”), Field Programmable Gate Array (“FPGA”), and/or thelike embedded technology. For example, any of the DOR componentcollection (distributed or otherwise) and/or features may be implementedvia the microprocessor and/or via embedded components; e.g., via ASIC,coprocessor, DSP, FPGA, and/or the like. Alternately, someimplementations of the DOR may be implemented with embedded componentsthat are configured and used to achieve a variety of features or signalprocessing.

Depending on the particular implementation, the embedded components mayinclude software solutions, hardware solutions, and/or some combinationof both hardware/software solutions. For example, DOR features discussedherein may be achieved through implementing FPGAs, which are asemiconductor devices containing programmable logic components called“logic blocks”, and programmable interconnects, such as the highperformance FPGA Virtex series and/or the low cost Spartan seriesmanufactured by Xilinx. Logic blocks and interconnects can be programmedby the customer or designer, after the FPGA is manufactured, toimplement any of the DOR features. A hierarchy of programmableinterconnects allow logic blocks to be interconnected as needed by theDOR system designer/administrator, somewhat like a one-chip programmablebreadboard. An FPGA's logic blocks can be programmed to perform thefunction of basic logic gates such as AND, and XOR, or more complexcombinational functions such as decoders or simple mathematicalfunctions. In most FPGAs, the logic blocks also include memory elements,which may be simple flip-flops or more complete blocks of memory. Insome circumstances, the DOR may be developed on regular FPGAs and thenmigrated into a fixed version that more resembles ASIC implementations.Alternate or coordinating implementations may migrate DOR controllerfeatures to a final ASIC instead of or in addition to FPGAs. Dependingon the implementation all of the aforementioned embedded components andmicroprocessors may be considered the “CPU” and/or “processor” for theDOR.

Power Source

The power source 986 may be of any standard form for powering smallelectronic circuit board devices such as the following power cells:alkaline, lithium hydride, lithium ion, lithium polymer, nickel cadmium,solar cells, and/or the like. Other types of AC or DC power sources maybe used as well. In the case of solar cells, in one embodiment, the caseprovides an aperture through which the solar cell may capture photonicenergy. The power cell 986 is connected to at least one of theinterconnected subsequent components of the DOR thereby providing anelectric current to all subsequent components. In one example, the powersource 986 is connected to the system bus component 904. In analternative embodiment, an outside power source 986 is provided througha connection across the I/O 908 interface. For example, a USB and/orIEEE 1394 connection carries both data and power across the connectionand is therefore a suitable source of power.

Interface Adapters

Interface bus(ses) 907 may accept, connect, and/or communicate to anumber of interface adapters, conventionally although not necessarily inthe form of adapter cards, such as but not limited to: input outputinterfaces (I/O) 908, storage interfaces 909, network interfaces 910,and/or the like. Optionally, cryptographic processor interfaces 927similarly may be connected to the interface bus. The interface busprovides for the communications of interface adapters with one anotheras well as with other components of the computer systemization.Interface adapters are adapted for a compatible interface bus. Interfaceadapters conventionally connect to the interface bus via a slotarchitecture. Conventional slot architectures may be employed, such as,but not limited to: Accelerated Graphics Port (AGP), Card Bus,(Extended) Industry Standard Architecture ((E)ISA), Micro ChannelArchitecture (MCA), NuBus, Peripheral Component Interconnect (Extended)(PCI(X)), PCI Express, Personal Computer Memory Card InternationalAssociation (PCMCIA), and/or the like.

Storage interfaces 909 may accept, communicate, and/or connect to anumber of storage devices such as, but not limited to: storage devices914, removable disc devices, and/or the like. Storage interfaces mayemploy connection protocols such as, but not limited to: (Ultra)(Serial) Advanced Technology Attachment (Packet Interface) ((Ultra)(Serial) ATA(PI)), (Enhanced) Integrated Drive Electronics ((E)IDE),Institute of Electrical and Electronics Engineers (IEEE) 1394, fiberchannel, Small Computer Systems Interface (SCSI), Universal Serial Bus(USB), and/or the like.

Network interfaces 910 may accept, communicate, and/or connect to acommunications network 913. Through a communications network 913, theDOR controller is accessible through remote clients 933 b (e.g.,computers with web browsers) by users 933 a. Network interfaces mayemploy connection protocols such as, but not limited to: direct connect,Ethernet (thick, thin, twisted pair 10/100/1000 Base T, and/or thelike), Token Ring, wireless connection such as IEEE 802.11a-x, and/orthe like. Should processing requirements dictate a greater amount speedand/or capacity, distributed network controllers (e.g., DistributedDOR), architectures may similarly be employed to pool, load balance,and/or otherwise increase the communicative bandwidth required by theDOR controller. A communications network may be any one and/or thecombination of the following: a direct interconnection; the Internet; aLocal Area Network (LAN); a Metropolitan Area Network (MAN); anOperating Missions as Nodes on the Internet (OMNI); a secured customconnection; a Wide Area Network (WAN); a wireless network (e.g.,employing protocols such as, but not limited to a Wireless ApplicationProtocol (WAP), I-mode, and/or the like); and/or the like. A networkinterface may be regarded as a specialized form of an input outputinterface. Further, multiple network interfaces 910 may be used toengage with various communications network types 913. For example,multiple network interfaces may be employed to allow for thecommunication over broadcast, multicast, and/or unicast networks.

Input Output interfaces (I/O) 908 may accept, communicate, and/orconnect to user input devices 911, peripheral devices 912, cryptographicprocessor devices 928, and/or the like. I/O may employ connectionprotocols such as, but not limited to: audio: analog, digital, monaural,RCA, stereo, and/or the like; data: Apple Desktop Bus (ADB), IEEE1394a-b, serial, universal serial bus (USB); infrared; joystick;keyboard; midi; optical; PC AT; PS/2; parallel; radio; video interface:Apple Desktop Connector (ADC), BNC, coaxial, component, composite,digital, Digital Visual Interface (DVI), high-definition multimediainterface (HDMI), RCA, RF antennae, S-Video, VGA, and/or the like;wireless: 802.11a/b/g/n/x, Bluetooth, code division multiple access(CDMA), global system for mobile communications (GSM), WiMax, etc.;and/or the like. One typical output device may include a video display,which typically comprises a Cathode Ray Tube (CRT) or Liquid CrystalDisplay (LCD) based monitor with an interface (e.g., DVI circuitry andcable) that accepts signals from a video interface, may be used. Thevideo interface composites information generated by a computersystemization and generates video signals based on the compositedinformation in a video memory frame. Another output device is atelevision set, which accepts signals from a video interface. Typically,the video interface provides the composited video information through avideo connection interface that accepts a video display interface (e.g.,an RCA composite video connector accepting an RCA composite video cable;a DVI connector accepting a DVI display cable, etc.).

User input devices 911 may be card readers, dongles, finger printreaders, gloves, graphics tablets, joysticks, keyboards, mouse (mice),remote controls, retina readers, trackballs, trackpads, and/or the like.

Peripheral devices 912 may be connected and/or communicate to I/O and/orother facilities of the like such as network interfaces, storageinterfaces, and/or the like. Peripheral devices may be audio devices,cameras, dongles (e.g., for copy protection, ensuring securetransactions with a digital signature, and/or the like), externalprocessors (for added functionality), goggles, microphones, monitors,network interfaces, printers, scanners, storage devices, video devices,video sources, visors, and/or the like.

It should be noted that although user input devices and peripheraldevices may be employed, the DOR controller may be embodied as anembedded, dedicated, and/or monitor-less (i.e., headless) device,wherein access would be provided over a network interface connection.

Cryptographic units such as, but not limited to, microcontrollers,processors 926, interfaces 927, and/or devices 928 may be attached,and/or communicate with the DOR controller. A MC68HC16 microcontroller,manufactured by Motorola Inc., may be used for and/or withincryptographic units. The MC68HC16 microcontroller utilizes a 16-bitmultiply-and-accumulate instruction in the 16 MHz configuration andrequires less than one second to perform a 512-bit RSA private keyoperation. Cryptographic units support the authentication ofcommunications from interacting agents, as well as allowing foranonymous transactions. Cryptographic units may also be configured aspart of CPU. Equivalent microcontrollers and/or processors may also beused. Other commercially available specialized cryptographic processorsinclude: the Broadcom's CryptoNetX and other Security Processors;nCipher's nShield, SafeNet's Luna PCI (e.g., 7100) series; SemaphoreCommunications' 40 MHz Roadrunner 184; Sun's Cryptographic Accelerators(e.g., Accelerator 6000 PCIe Board, Accelerator 500 Daughtercard); ViaNano Processor (e.g., L2100, L2200, U2400) line, which is capable ofperforming 500+ MB/s of cryptographic instructions; VLSI Technology's 33MHz 6868; and/or the like.

Memory

Generally, any mechanization and/or embodiment allowing a processor toaffect the storage and/or retrieval of information is regarded as memory929. However, memory is a fungible technology and resource, thus, anynumber of memory embodiments may be employed in lieu of or in concertwith one another. It is to be understood that the DOR controller and/ora computer systemization may employ various forms of memory 929. Forexample, a computer systemization may be configured wherein thefunctionality of on-chip CPU memory (e.g., registers), RAM, ROM, and anyother storage devices are provided by a paper punch tape or paper punchcard mechanism; of course such an embodiment would result in anextremely slow rate of operation. In a typical configuration, memory 929will include ROM 906, RAM 905, and a storage device 914. A storagedevice 914 may be any conventional computer system storage. Storagedevices may include a drum; a (fixed and/or removable) magnetic diskdrive; a magneto-optical drive; an optical drive (i.e., Blueray, CDROM/RAM/Recordable (R)/ReWritable (RW), DVD R/RW, HD DVD R/RW etc.); anarray of devices (e.g., Redundant Array of Independent Disks (RAID));solid state memory devices (USB memory, solid state drives (SSD), etc.);other processor-readable storage mediums; and/or other devices of thelike. Thus, a computer systemization generally requires and makes use ofmemory.

Component Collection

The memory 929 may contain a collection of program and/or databasecomponents and/or data such as, but not limited to: operating systemcomponent(s) 915 (operating system); information server component(s) 916(information server); user interface component(s) 917 (user interface);Web browser component(s) 918 (Web browser); database(s) 919; mail servercomponent(s) 921; mail client component(s) 922; cryptographic servercomponent(s) 920 (cryptographic server); the DOR component(s) 935;and/or the like (i.e., collectively a component collection). Thesecomponents may be stored and accessed from the storage devices and/orfrom storage devices accessible through an interface bus. Althoughnon-conventional program components such as those in the componentcollection, typically, are stored in a local storage device 914, theymay also be loaded and/or stored in memory such as: peripheral devices,RAM, remote storage facilities through a communications network, ROM,various forms of memory, and/or the like.

Operating System

The operating system component 915 is an executable program componentfacilitating the operation of the DOR controller. Typically, theoperating system facilitates access of I/O, network interfaces,peripheral devices, storage devices, and/or the like. The operatingsystem may be a highly fault tolerant, scalable, and secure system suchas: Apple Macintosh OS X (Server); AT&T Nan 9; Be OS; Unix and Unix-likesystem distributions (such as AT&T's UNIX; Berkley Software Distribution(BSD) variations such as FreeBSD, NetBSD, OpenBSD, and/or the like;Linux distributions such as Red Hat, Ubuntu, and/or the like); and/orthe like operating systems. However, more limited and/or less secureoperating systems also may be employed such as Apple Macintosh OS, IBMOS/2, Microsoft DOS, Microsoft Windows2000/2003/3.1/95/98/CE/Millenium/NT/Vista/XP (Server), Palm OS, and/orthe like. An operating system may communicate to and/or with othercomponents in a component collection, including itself, and/or the like.Most frequently, the operating system communicates with other programcomponents, user interfaces, and/or the like. For example, the operatingsystem may contain, communicate, generate, obtain, and/or provideprogram component, system, user, and/or data communications, requests,and/or responses. The operating system, once executed by the CPU, mayenable the interaction with communications networks, data, I/O,peripheral devices, program components, memory, user input devices,and/or the like. The operating system may provide communicationsprotocols that allow the DOR controller to communicate with otherentities through a communications network 913. Various communicationprotocols may be used by the DOR controller as a subcarrier transportmechanism for interaction, such as, but not limited to: multicast,TCP/IP, UDP, unicast, and/or the like.

Information Server

An information server component 916 is a stored program component thatis executed by a CPU. The information server may be a conventionalInternet information server such as, but not limited to Apache SoftwareFoundation's Apache, Microsoft's Internet Information Server, and/or thelike. The information server may allow for the execution of programcomponents through facilities such as Active Server Page (ASP), ActiveX,(ANSI) (Objective-) C (++), C# and/or .NET, Common Gateway Interface(CGI) scripts, dynamic (D) hypertext markup language (HTML), FLASH,Java, JavaScript, Practical Extraction Report Language (PERL), HypertextPre-Processor (PHP), pipes, Python, wireless application protocol (WAP),WebObjects, and/or the like. The information server may support securecommunications protocols such as, but not limited to, File TransferProtocol (FTP); HyperText Transfer Protocol (HTTP); Secure HypertextTransfer Protocol (HTTPS), Secure Socket Layer (SSL), messagingprotocols (e.g., America Online (AOL) Instant Messenger (AIM),Application Exchange (APEX), ICQ, Internet Relay Chat (IRC), MicrosoftNetwork (MSN) Messenger Service, Presence and Instant Messaging Protocol(PRIM), Internet Engineering Task Force's (IETF's) Session InitiationProtocol (SIP), SIP for Instant Messaging and Presence LeveragingExtensions (SIMPLE), open XML-based Extensible Messaging and PresenceProtocol (XMPP) (i.e., Jabber or Open Mobile Alliance's (OMA's) InstantMessaging and Presence Service (IMPS)), Yahoo! Instant MessengerService, and/or the like. The information server provides results in theform of Web pages to Web browsers, and allows for the manipulatedgeneration of the Web pages through interaction with other programcomponents. After a Domain Name System (DNS) resolution portion of anHTTP request is resolved to a particular information server, theinformation server resolves requests for information at specifiedlocations on the DOR controller based on the remainder of the HTTPrequest. For example, a request such ashttp://123.124.125.126/myInformation.html might have the IP portion ofthe request “123.124.125.126” resolved by a DNS server to an informationserver at that IP address; that information server might in turn furtherparse the http request for the “/myInformation.html” portion of therequest and resolve it to a location in memory containing theinformation “myInformation.html.” Additionally, other informationserving protocols may be employed across various ports, e.g., FTPcommunications across port 21, and/or the like. An information servermay communicate to and/or with other components in a componentcollection, including itself, and/or facilities of the like. Mostfrequently, the information server communicates with the DOR database919, operating systems, other program components, user interfaces, Webbrowsers, and/or the like.

Access to the DOR database may be achieved through a number of databasebridge mechanisms such as through scripting languages as enumeratedbelow (e.g., CGI) and through inter-application communication channelsas enumerated below (e.g., CORBA, WebObjects, etc.). Any data requeststhrough a Web browser are parsed through the bridge mechanism intoappropriate grammars as required by the DOR. In one embodiment, theinformation server would provide a Web form accessible by a Web browser.Entries made into supplied fields in the Web form are tagged as havingbeen entered into the particular fields, and parsed as such. The enteredterms are then passed along with the field tags, which act to instructthe parser to generate queries directed to appropriate tables and/orfields. In one embodiment, the parser may generate queries in standardSQL by instantiating a search string with the proper join/selectcommands based on the tagged text entries, wherein the resulting commandis provided over the bridge mechanism to the DOR as a query. Upongenerating query results from the query, the results are passed over thebridge mechanism, and may be parsed for formatting and generation of anew results Web page by the bridge mechanism. Such a new results Webpage is then provided to the information server, which may supply it tothe requesting Web browser.

Also, an information server may contain, communicate, generate, obtain,and/or provide program component, system, user, and/or datacommunications, requests, and/or responses.

User Interface

The function of computer interfaces in some respects is similar toautomobile operation interfaces. Automobile operation interface elementssuch as steering wheels, gearshifts, and speedometers facilitate theaccess, operation, and display of automobile resources, functionality,and status. Computer interaction interface elements such as check boxes,cursors, menus, scrollers, and windows (collectively and commonlyreferred to as widgets) similarly facilitate the access, operation, anddisplay of data and computer hardware and operating system resources,functionality, and status. Operation interfaces are commonly called userinterfaces. Graphical user interfaces (GUIs) such as the Apple MacintoshOperating System's Aqua, IBM's OS/2, Microsoft's Windows2000/2003/3.1/95/98/CE/Millenium/NT/XP/15 Vista/7 (i.e., Aero), Unix'sX-Windows (e.g., which may include additional Unix graphic 16 interfacelibraries and layers such as K Desktop Environment (KDE), mythTV and GNUNetwork Object Model Environment (GNOME)), web interface libraries(e.g., ActiveX, AJAX, (D)HTML, FLASH, Java, JavaScript, etc. interfacelibraries such as, but not limited to, Dojo, jQuery(UI), MooTools,Prototype, script.aculo.us, SWFObject, Yahoo! User Interface, any ofwhich may be used and) provide a baseline and means of accessing anddisplaying information graphically to users.

A user interface component 917 is a stored program component that isexecuted by a CPU. The user interface may be a conventional graphic userinterface as provided by, with, and/or atop operating systems and/oroperating environments such as already discussed. The user interface mayallow for the display, execution, interaction, manipulation, and/oroperation of program components and/or system facilities through textualand/or graphical facilities. The user interface provides a facilitythrough which users may affect, interact, and/or operate a computersystem. A user interface may communicate to and/or with other componentsin a component collection, including itself, and/or facilities of thelike. Most frequently, the user interface communicates with operatingsystems, other program components, and/or the like. The user interfacemay contain, communicate, generate, obtain, and/or provide programcomponent, system, user, and/or data communications, requests, and/orresponses.

Web Browser

A Web browser component 918 is a stored program component that isexecuted by a CPU. The Web browser may be a conventional hypertextviewing application such as Microsoft Internet Explorer or NetscapeNavigator. Secure Web browsing may be supplied with 128 bit (or greater)encryption by way of HTTPS, SSL, and/or the like. Web browsers allowingfor the execution of program components through facilities such asActiveX, AJAX, (D)HTML, FLASH, Java, JavaScript, web browser plug-inAPIs (e.g., FireFox, Safari Plug-in, and/or the like APIs), and/or thelike. Web browsers and like information access tools may be integratedinto PDAs, cellular telephones, and/or other mobile devices. A Webbrowser may communicate to and/or with other components in a componentcollection, including itself, and/or facilities of the like. Mostfrequently, the Web browser communicates with information servers,operating systems, integrated program components (e.g., plug-ins),and/or the like; e.g., it may contain, communicate, generate, obtain,and/or provide program component, system, user, and/or datacommunications, requests, and/or responses. Of course, in place of a Webbrowser and information server, a combined application may be developedto perform similar functions of both. The combined application wouldsimilarly affect the obtaining and the provision of information tousers, user agents, and/or the like from the DOR enabled nodes. Thecombined application may be nugatory on systems employing standard Webbrowsers.

Mail Server

A mail server component 921 is a stored program component that isexecuted by a CPU 903. The mail server may be a conventional Internetmail server such as, but not limited to sendmail, Microsoft Exchange,and/or the like. The mail server may allow for the execution of programcomponents through facilities such as ASP, ActiveX, (ANSI) (Objective-)C (++), C# and/or .NET, CGI scripts, Java, JavaScript, PERL, PHP, pipes,Python, WebObjects, and/or the like. The mail server may supportcommunications protocols such as, but not limited to: Internet messageaccess protocol (IMAP), Messaging Application Programming Interface(MAPI)/Microsoft Exchange, post office protocol (POPS), simple mailtransfer protocol (SMTP), and/or the like. The mail server can route,forward, and process incoming and outgoing mail messages that have beensent, relayed and/or otherwise traversing through and/or to the DOR.

Access to the DOR mail may be achieved through a number of APIs offeredby the individual Web server components and/or the operating system.

Also, a mail server may contain, communicate, generate, obtain, and/orprovide program component, system, user, and/or data communications,requests, information, and/or responses.

Mail Client

A mail client component 922 is a stored program component that isexecuted by a CPU 903. The mail client may be a conventional mailviewing application such as Apple Mail, Microsoft Entourage, MicrosoftOutlook, Microsoft Outlook Express, Mozilla, Thunderbird, and/or thelike. Mail clients may support a number of transfer protocols, such as:IMAP, Microsoft Exchange, POP₃, SMTP, and/or the like. A mail client maycommunicate to and/or with other components in a component collection,including itself, and/or facilities of the like. Most frequently, themail client communicates with mail servers, operating systems, othermail clients, and/or the like; e.g., it may contain, communicate,generate, obtain, and/or provide program component, system, user, and/ordata communications, requests, information, and/or responses. Generally,the mail client provides a facility to compose and transmit electronicmail messages.

Cryptographic Server

A cryptographic server component 92 o is a stored program component thatis executed by a CPU 903, cryptographic processor 926, cryptographicprocessor interface 927, cryptographic processor device 928, and/or thelike. Cryptographic processor interfaces will allow for expedition ofencryption and/or decryption requests by the cryptographic component;however, the cryptographic component, alternatively, may run on aconventional CPU. The cryptographic component allows for the encryptionand/or decryption of provided data. The cryptographic component allowsfor both symmetric and asymmetric (e.g., Pretty Good Protection (PGP))encryption and/or decryption. The cryptographic component may employcryptographic techniques such as, but not limited to: digitalcertificates (e.g., X.509 authentication framework), digital signatures,dual signatures, enveloping, password access protection, public keymanagement, and/or the like. The cryptographic component will facilitatenumerous (encryption and/or decryption) security protocols such as, butnot limited to: checksum, Data Encryption Standard (DES), EllipticalCurve Encryption (ECC), International Data Encryption Algorithm (IDEA),Message Digest 5 (MD5, which is a one way hash function), passwords,Rivest Cipher (RC5), Rijndael, RSA (which is an Internet encryption andauthentication system that uses an algorithm developed in 1977 by RonRivest, Adi Shamir, and Leonard Adleman), Secure Hash Algorithm (SHA),Secure Socket Layer (SSL), Secure Hypertext Transfer Protocol (HTTPS),and/or the like. Employing such encryption security protocols, the DORmay encrypt all incoming and/or outgoing communications and may serve asnode within a virtual private network (VPN) with a wider communicationsnetwork. The cryptographic component facilitates the process of“security authorization” whereby access to a resource is inhibited by asecurity protocol wherein the cryptographic component effects authorizedaccess to the secured resource. In addition, the cryptographic componentmay provide unique identifiers of content, e.g., employing and MD5 hashto obtain a unique signature for an digital audio file. A cryptographiccomponent may communicate to and/or with other components in a componentcollection, including itself, and/or facilities of the like. Thecryptographic component supports encryption schemes allowing for thesecure transmission of information across a communications network toenable the DOR component to engage in secure transactions if so desired.The cryptographic component facilitates the secure accessing ofresources on the DOR and facilitates the access of secured resources onremote systems; i.e., it may act as a client and/or server of securedresources. Most frequently, the cryptographic component communicateswith information servers, operating systems, other program components,and/or the like. The cryptographic component may contain, communicate,generate, obtain, and/or provide program component, system, user, and/ordata communications, requests, and/or responses.

The DOR Database

The DOR database component 919 may be embodied in a database and itsstored data. The database is a stored program component, which isexecuted by the CPU; the stored program component portion configuringthe CPU to process the stored data. The database may be a conventional,fault tolerant, relational, scalable, secure database such as Oracle orSybase. Relational databases are an extension of a flat file. Relationaldatabases consist of a series of related tables. The tables areinterconnected via a key field. Use of the key field allows thecombination of the tables by indexing against the key field; i.e., thekey fields act as dimensional pivot points for combining informationfrom various tables. Relationships generally identify links maintainedbetween tables by matching primary keys. Primary keys represent fieldsthat uniquely identify the rows of a table in a relational database.More precisely, they uniquely identify rows of a table on the “one” sideof a one-to-many relationship.

Alternatively, the DOR database may be implemented using variousstandard data-structures, such as an array, hash, (linked) list, struct,structured text file (e.g., XML), table, and/or the like. Suchdata-structures may be stored in memory and/or in (structured) files. Inanother alternative, an object-oriented database may be used, such asFrontier, ObjectStore, Poet, Zope, and/or the like. Object databases caninclude a number of object collections that are grouped and/or linkedtogether by common attributes; they may be related to other objectcollections by some common attributes. Object-oriented databases performsimilarly to relational databases with the exception that objects arenot just pieces of data but may have other types of functionalityencapsulated within a given object. If the DOR database is implementedas a data-structure, the use of the DOR database 919 may be integratedinto another component such as the DOR component 935. Also, the databasemay be implemented as a mix of data structures, objects, and relationalstructures. Databases may be consolidated and/or distributed incountless variations through standard data processing techniques.Portions of databases, e.g., tables, may be exported and/or imported andthus decentralized and/or integrated.

In one embodiment, the database component 919 includes several tables919 a-h. A Users table 919 a may include fields such as, but not limitedto: user_ID, ssn, first_name, last_name, middle_name, suffix, prefix,address_first_line, address_second_line, city, state, zipcode, country,birth_date, gender, device_ID_list, device_name_list, device_type_list,hardware_configuration_list, software_apps_list, device_IP_list,device_MAC_list, device_preferences_list, and/or the like. An Apps table919 b may include fields such as, but not limited to: app_ID, app_name,app_type, app_version, app_version_timestamp, app_prior_versions_list,app_prior_versions_timestamps, app_update_schedule,app_scheduled_versions_list, app_scheduled_versions_dates,app_scheduled_versions_priority, app_enviroment_type,app_environment_version, app_compatibilities_hw, app_compatibilities_sw,app_dependent_topology_tree, app_depend_module_list,app_depend_function_list, app_depend_apps_list, and/or the like. A Codetable 919 c may include fields such as, but not limited to: code_ID,code_name, code_type, code_version, code_version_timestamp,code_prior_versions_list, code_prior_versions_timestamps,code_update_schedule, code_scheduled_versions_list,code_scheduled_versions_dates, code_scheduled_versions_priority,code_enviroment_type, code_environment_version, code_compatibilities_hw,code_compatibilities_sw, code_dependent_topology_tree,code_depend_module_list, code_depend_function_list, code_dependcodes_list, and/or the like. A Queues table 919 d may include fieldssuch as, but not limited to: render_request_ID, render_request_fields,render_request_string, render_request_origin, render_request_timestamp,render_request_priority, render_request_queue_ID,render_request_attempts, and/or the like. A Host Server table 919 e mayinclude fields such as, but not limited to: user_id, user_name, app_id,app_name, api_list, api_function_list, client_id, language_pref, and/orthe like. A Computing Server table 919 f may include fields such as, butnot limited to: job_id, job_app_server_id, user_id, user_data and/or thelike. An App Server table 919 g may include fields such as, but notlimited to: app_id, app_name, app_versions, app_update_schedule,app_dependencies, app_specifications_list, and/or the like. A Clienttable 919 h may include fields such as, but not limited to: user_id,user_name, client_ip_address, client_type, and/or the like. A Templatetable 919 i may include fields such as, but not limited to: host_id,host_specifications_list, attachments_list, target_id, message, note,comment, submit_user_id, and/or the like. One or more of the tablesdiscussed above may support and/or track multiple entity accounts on aDOR.

In one embodiment, the DOR database may interact with other databasesystems. For example, employing a distributed database system, queriesand data access by search DOR component may treat the combination of theDOR database, an integrated data security layer database as a singledatabase entity.

In one embodiment, user programs may contain various user interfaceprimitives, which may serve to update the DOR. Also, various accountsmay require custom database tables depending upon the environments andthe types of clients the DOR may need to serve. It should be noted thatany unique fields may be designated as a key field throughout. In analternative embodiment, these tables have been decentralized into theirown databases and their respective database controllers (i.e.,individual database controllers for each of the above tables). Employingstandard data processing techniques, one may further distribute thedatabases over several computer systemizations and/or storage devices.Similarly, configurations of the decentralized database controllers maybe varied by consolidating and/or distributing the various databasecomponents 919 a-s. The DOR may be configured to keep track of varioussettings, inputs, and parameters via database controllers.

The DOR database may communicate to and/or with other components in acomponent collection, including itself, and/or facilities of the like.Most frequently, the DOR database communicates with the DOR component,other program components, and/or the like. The database may contain,retain, and provide information regarding other nodes and data.

The DORs

The DOR component 935 is a stored program component that is executed bya CPU. In one embodiment, the DOR component incorporates any and/or allcombinations of the aspects of the DOR discussed in the previousfigures. As such, the DOR affects accessing, obtaining and the provisionof information, services, transactions, and/or the like across variouscommunications networks.

The DOR component enables live reconciliation of code updates tomulti-user social networking applications in highly dynamic buildenvironments, and/or the like and use of the DOR. In one embodiment,user inputs and selections of activities 402-414 are transformed via theclient initialization component, the client transaction component, therender request processing component, and the request managementcomponent into target social postings 417-420.

The DOR component enabling access of information between nodes may bedeveloped by employing standard development tools and languages such as,but not limited to: Apache components, Assembly, ActiveX, binaryexecutables, (ANSI) (Objective-) C (++), C# and/or .NET, databaseadapters, CGI scripts, Java, JavaScript, mapping tools, procedural andobject oriented development tools, PERL, PHP, Python, shell scripts, SQLcommands, web application server extensions, web developmentenvironments and libraries (e.g., Microsoft's ActiveX; Adobe AIR, FLEX &FLASH; AJAX; (D)HTML; Dojo, Java; JavaScript; jQuery(UI); MooTools;Prototype; script.aculo.us; Simple Object Access Protocol (SOAP);SWFObject; Yahoo! User Interface; and/or the like), WebObjects, and/orthe like. In one embodiment, the DOR server employs a cryptographicserver to encrypt and decrypt communications. The DOR component maycommunicate to and/or with other components in a component collection,including itself, and/or facilities of the like. Most frequently, theDOR component communicates with the DOR database, operating systems,other program components, and/or the like. The DOR may contain,communicate, generate, obtain, and/or provide program component, system,user, and/or data communications, requests, and/or responses.

Distributed DORs

The structure and/or operation of any of the DOR node controllercomponents may be combined, consolidated, and/or distributed in anynumber of ways to facilitate development and/or deployment. Similarly,the component collection may be combined in any number of ways tofacilitate deployment and/or development. To accomplish this, one mayintegrate the components into a common code base or in a facility thatcan dynamically load the components on demand in an integrated fashion.

The component collection may be consolidated and/or distributed incountless variations through standard data processing and/or developmenttechniques. Multiple instances of any one of the program components inthe program component collection may be instantiated on a single node,and/or across numerous nodes to improve performance throughload-balancing and/or data-processing techniques. Furthermore, singleinstances may also be distributed across multiple controllers and/orstorage devices; e.g., databases. All program component instances andcontrollers working in concert may do so through standard dataprocessing communication techniques. For example, DOR server(s) anddatabase(s) may all be localized within a single computing terminal. Asanother example, the DOR components may be localized within one or moreentities (e.g., hospitals, pharmaceutical companies etc.) involved incoordinated patient management.

The configuration of the DOR controller will depend on the context ofsystem deployment. Factors such as, but not limited to, the budget,capacity, location, and/or use of the underlying hardware resources mayaffect deployment requirements and configuration. Regardless of if theconfiguration results in more consolidated and/or integrated programcomponents, results in a more distributed series of program components,and/or results in some combination between a consolidated anddistributed configuration, data may be communicated, obtained, and/orprovided. Instances of components consolidated into a common code basefrom the program component collection may communicate, obtain, and/orprovide data. This may be accomplished through intra-application dataprocessing communication techniques such as, but not limited to: datareferencing (e.g., pointers), internal messaging, object instancevariable communication, shared memory space, variable passing, and/orthe like.

If component collection components are discrete, separate, and/orexternal to one another, then communicating, obtaining, and/or providingdata with and/or to other component components may be accomplishedthrough inter-application data processing communication techniques suchas, but not limited to: Application Program Interfaces (API) informationpassage; (distributed) Component Object Model ((D)COM), (Distributed)Object Linking and Embedding ((D)OLE), and/or the like), Common ObjectRequest Broker Architecture (CORBA), local and remote applicationprogram interfaces Jini, Remote Method Invocation (RMI), SOAP, processpipes, shared files, and/or the like. Messages sent between discretecomponent components for inter-application communication or withinmemory spaces of a singular component for intra-applicationcommunication may be facilitated through the creation and parsing of agrammar. A grammar may be developed by using standard development toolssuch as lex, yacc, XML, and/or the like, which allow for grammargeneration and parsing functionality, which in turn may form the basisof communication messages within and between components. For example, agrammar may be arranged to recognize the tokens of an HTTP post command,e.g.:

w3c -post http:// . . . . Value1

where Value1 is discerned as being a parameter because “http://” is partof the grammar syntax, and what follows is considered part of the postvalue. Similarly, with such a grammar, a variable “Value1” may beinserted into an “http://” post command and then sent. The grammarsyntax itself may be presented as structured data that is interpretedand/or other wise used to generate the parsing mechanism (e.g., a syntaxdescription text file as processed by lex, yacc, etc.). Also, once theparsing mechanism is generated and/or instantiated, it itself mayprocess and/or parse structured data such as, but not limited to:character (e.g., tab) delineated text, HTML, structured text streams,XML, and/or the like structured data. In another embodiment,inter-application data processing protocols themselves may haveintegrated and/or readily available parsers (e.g., the SOAP parser) thatmay be employed to parse communications data. Further, the parsinggrammar may be used beyond message parsing, but may also be used toparse: databases, data collections, data stores, structured data, and/orthe like. Again, the desired configuration will depend upon the context,environment, and requirements of system deployment.

Non-limiting exemplary embodiments highlighting numerous furtheradvantageous aspects include:

1. A distributed rendering processor-implemented method embodiment,comprising:

-   -   obtaining a request to render an image of a visualization        included in a client app;    -   analyzing the render request to determine data required for        render processing;    -   providing a request for the data required for render processing;    -   obtaining the data required for render processing upon providing        the request for the required data;    -   recreating an app state of the client app using the obtained        data required for render processing, the recreated app state        including data related to the visualization included in the        client app; and    -   rendering the image of the visualization including in the client        app using the recreated app state.

2. The method of embodiment 1, further comprising:

-   -   generating a publishing element using the rendered image of the        visualization included in the client app; and    -   providing the publishing element for publication.

3. The method of embodiment 1, wherein the client app is included in anAdobe Flash object.

4. The method of embodiment 1, wherein the client app includes amassively multiplayer gaming application.

5. The method of embodiment 1, wherein providing a request for the datarequired for render processing includes querying a database for therequired data.

6. The method of embodiment 1, wherein the request for the data requiredfor render processing is provided for a client executing the client app.

7. The method of embodiment 2, wherein the publishing element includes amessage for posting on a Facebook webpage.

8. A distributed rendering system embodiment, comprising:

-   -   a processor; and    -   a memory disposed in communication with the processor and        storing processor-executable instructions, the instructions        comprising instructions to:        -   obtain a request to render an image of a visualization            included in a client app;        -   analyze the render request to determine data required for            render processing;        -   provide a request for the data required for render            processing;        -   obtain the data required for render processing upon            providing the request for the required data;        -   recreate an app state of the client app using the obtained            data required for render processing, the recreated app state            including data related to the visualization included in the            client app; and        -   render the image of the visualization including in the            client app using the recreated app state.

9. The system of embodiment 8, the instructions further comprisinginstructions to:

-   -   generate a publishing element using the rendered image of the        visualization included in the client app; and    -   provide the publishing element for publication.

10. The system of embodiment 8, wherein the client app is included in anAdobe Flash object.

11. The system of embodiment 8, wherein the client app includes amassively multiplayer gaming application.

12. The system of embodiment 8, wherein providing a request for the datarequired for render processing includes querying a database for therequired data.

13. The system of embodiment 8, wherein the request for the datarequired for render processing is provided for a client executing theclient app.

14. The system of embodiment 9, wherein the publishing element includesa message for posting on a Facebook webpage.

15. A processor-readable medium embodiment storing processor-executabledistributed rendering instructions, the instructions comprisinginstructions to:

-   -   obtain a request to render an image of a visualization included        in a client app;    -   analyze the render request to determine data required for render        processing;    -   provide a request for the data required for render processing;    -   obtain the data required for render processing upon providing        the request for the required data;    -   recreate an app state of the client app using the obtained data        required for render processing, the recreated app state        including data related to the visualization included in the        client app; and    -   render the image of the visualization including in the client        app using the recreated app state.

16. The medium of embodiment 15, the instructions further comprisinginstructions to:

-   -   generate a publishing element using the rendered image of the        visualization included in the client app; and    -   provide the publishing element for publication.

17. The medium of embodiment 15, wherein the client app is included inan Adobe Flash object.

18. The medium of embodiment 15, wherein the client app includes amassively multiplayer gaming application.

19. The medium of embodiment 15, wherein providing a request for thedata required for render processing includes querying a database for therequired data.

-   -   20. The medium of embodiment 15, wherein the request for the        data required for render processing is provided for a client        executing the client app.

21. The system of embodiment 16, wherein the publishing element includesa message for posting on a Facebook webpage.

22. A rendering request processor-implemented method embodiment,comprising:

-   -   obtaining a client app from an app database;    -   obtaining user input from a user for the client app;    -   generating data pertaining to a visualization included in the        client app based on the obtained user input;    -   providing a request for rendering an image of the visualization        included in the client app; and    -   providing the data pertaining to the visualization for        processing the request for rendering the image of the        visualization included in the client app.

23. The method of embodiment 22, further comprising:

-   -   providing an indication to publish the image of the        visualization included in the client app.

24. The method of embodiment 22, further comprising:

-   -   obtaining data associated with the client app and pertaining to        a member of a social graph of the user; and    -   wherein generating data pertaining to the visualization included        in the client app is further based on the obtained data        pertaining to the member of the social graph of the user.

25. The method of embodiment 22, wherein the client app includes amassively multiplayer gaming application.

26. The method of embodiment 22, wherein the client app is included inan Adobe Flash object.

27. The method of embodiment 22, wherein providing the data pertainingto the visualization for processing the request for rendering the imageincludes:

-   -   freezing a state of the client app; and    -   obtaining a snapshot of the frozen state of the client app.

28. The method of embodiment 23, wherein the indication includes anindication to publish the image of the visualization included in theclient app to a Facebook webpage.

29. A rendering request apparatus embodiment, comprising:

-   -   a processor; and    -   a memory disposed in communication with the processor and        storing processor-executable instructions, the instructions        comprising instructions to:        -   obtain a client app from an app database;        -   obtain user input from a user for the client app;        -   generate data pertaining to a visualization included in the            client app based on the obtained user input;        -   provide a request for rendering an image of the            visualization included in the client app; and        -   provide the data pertaining to the visualization for            processing the request for rendering the image of the            visualization included in the client app.

30. The apparatus of embodiment 29, the instructions further comprisinginstructions to:

-   -   provide an indication to publish the image of the visualization        included in the client app.

31. The apparatus of embodiment 29, the instructions further comprisinginstructions to:

-   -   obtain data associated with the client app and pertaining to a        member of a social graph of the user; and    -   wherein generating data pertaining to the visualization included        in the client app is further based on the obtained data        pertaining to the member of the social graph of the user.

32. The apparatus of embodiment 29, wherein the client app includes amassively multiplayer gaming application.

33. The apparatus of embodiment 29, wherein the client app is includedin an Adobe Flash object.

34. The apparatus of embodiment 29, wherein the instructions to providethe data pertaining to the visualization for processing the request forrendering the image include instructions to:

-   -   freeze a state of the client app; and    -   obtain a snapshot of the frozen state of the client app.

35. The apparatus of embodiment 30, wherein the indication includes anindication to publish the image of the visualization included in theclient app to a Facebook webpage.

36. A processor-readable medium embodiment storing processor-executablerendering request instructions, the instructions comprising instructionsto:

-   -   obtain a client app from an app database;    -   obtain user input from a user for the client app;    -   generate data pertaining to a visualization included in the        client app based on the obtained user input;    -   provide a request for rendering an image of the visualization        included in the client app; and    -   provide the data pertaining to the visualization for processing        the request for rendering the image of the visualization        included in the client app.

37. The medium of embodiment 36, the instructions further comprisinginstructions to:

-   -   provide an indication to publish the image of the visualization        included in the client app.

38. The medium of embodiment 36, the instructions further comprisinginstructions to:

-   -   obtain data associated with the client app and pertaining to a        member of a social graph of the user; and    -   wherein generating data pertaining to the visualization included        in the client app is further based on the obtained data        pertaining to the member of the social graph of the user.

39. The medium of embodiment 36, wherein the client app includes amassively multiplayer gaming application.

40. The medium of embodiment 36, wherein the client app is included inan Adobe Flash object.

41. The medium of embodiment 36, wherein the instructions to provide thedata pertaining to the visualization for processing the request forrendering the image include instructions to:

-   -   freeze a state of the client app; and    -   obtain a snapshot of the frozen state of the client app.

42. The medium of embodiment 37, wherein the indication includes anindication to publish the image of the visualization included in theclient app to a Facebook webpage.

In order to address various issues and improve over the prior art, theinvention is directed to apparatuses, methods and systems for a mobilehealthcare management system. The entirety of this application(including the Cover Page, Title, Headings, Field, Background, Summary,Brief Description of the Drawings, Detailed Description, Claims,Abstract, Figures, Appendices and/or otherwise) shows by way ofillustration various embodiments in which the claimed inventions may bepracticed. The advantages and features of the application are of arepresentative sample of embodiments only, and are not exhaustive and/orexclusive. They are presented only to assist in understanding and teachthe claimed principles. It should be understood that they are notrepresentative of all claimed inventions. As such, certain aspects ofthe disclosure have not been discussed herein. That alternateembodiments may not have been presented for a specific portion of theinvention or that further undescribed alternate embodiments may beavailable for a portion is not to be considered a disclaimer of thosealternate embodiments. It will be appreciated that many of thoseundescribed embodiments incorporate the same principles of the inventionand others are equivalent. Thus, it is to be understood that otherembodiments may be utilized and functional, logical, organizational,structural and/or topological modifications may be made withoutdeparting from the scope and/or spirit of the disclosure. As such, allexamples and/or embodiments are deemed to be non-limiting throughoutthis disclosure. Also, no inference should be drawn regarding thoseembodiments discussed herein relative to those not discussed hereinother than it is as such for purposes of reducing space and repetition.For instance, it is to be understood that the logical and/or topologicalstructure of any combination of any program components (a componentcollection), other components and/or any present feature sets asdescribed in the figures and/or throughout are not limited to a fixedoperating order and/or arrangement, but rather, any disclosed order isexemplary and all equivalents, regardless of order, are contemplated bythe disclosure. Furthermore, it is to be understood that such featuresare not limited to serial execution, but rather, any number of threads,processes, services, servers, and/or the like that may executeasynchronously, concurrently, in parallel, simultaneously,synchronously, and/or the like are contemplated by the disclosure. Assuch, some of these features may be mutually contradictory, in that theycannot be simultaneously present in a single embodiment. Similarly, somefeatures are applicable to one aspect of the invention, and inapplicableto others. In addition, the disclosure includes other inventions notpresently claimed. Applicant reserves all rights in those presentlyunclaimed inventions including the right to claim such inventions, fileadditional applications, continuations, continuations in part,divisions, and/or the like thereof. As such, it should be understoodthat advantages, embodiments, examples, functional, features, logical,organizational, structural, topological, and/or other aspects of thedisclosure are not to be considered limitations on the disclosure asdefined by the claims or limitations on equivalents to the claims. It isto be understood that, depending on the particular needs of the DORand/or characteristics of the hardware, software, network framework,monetization model and/or the like, various embodiments of the DOR maybe implemented that enable a great deal of flexibility andcustomization. It is to be understood that, depending on the particularneeds of the DOR and/or characteristics of the hardware, software,network framework, monetization model and/or the like, variousembodiments of the DOR may be implemented that enable a great deal offlexibility and customization. The instant disclosure discusses exampleimplementations of the DOR within the context of multi-user gamingapplications. However, it is to be understood that the system describedherein can be readily configured for a wide range of other applicationsand/or implementations. For example, implementations of the DOR can beconfigured to operate within the context of blogging, micro-blogging,professional networking, and/or the like. Alternate implementations ofthe system may be utilized in various contexts outside socialnetworking, including, but not limited to, officeproductivity/collaboration software, distributed online advertising,networked surveillance systems, sensor networks, and/or the like. It isto be understood that the DOR may be further adapted to otherimplementations and/or software management.

1. A processor-implemented distributed rendering method, comprising:obtaining a request to render an image of a visualization included in aclient app; analyzing the render request to determine data required forrender processing; providing a request for the data required for renderprocessing; obtaining the data required for render processing uponproviding the request for the required data; recreating an app state ofthe client app using the obtained data required for render processing,the recreated app state including data related to the visualizationincluded in the client app; and rendering the image of the visualizationincluded in the client app using the recreated app state.
 2. The methodof claim 1, further comprising: generating a publishing element usingthe rendered image of the visualization included in the client app; andproviding the publishing element for publication.
 3. The method of claim1, wherein the client app is included in an Adobe Flash object.
 4. Themethod of claim 1, wherein the client app includes a massivelymultiplayer gaming application.
 5. The method of claim 1, whereinproviding a request for the data required for render processing includesquerying a database for the required data.
 6. The method of claim 1,wherein the request for the data required for render processing isprovided for a client executing the client app.
 7. The method of claim2, wherein the publishing element includes a message for posting on aFacebook webpage.
 8. The method of claim 1, wherein the image of thevisualization included in the client app is rendered in one of: JPEG;GIF; PNG; and BMP formats.
 9. A distributed rendering system,comprising: a processor; and a memory disposed in communication with theprocessor and storing processor-executable instructions, theinstructions comprising instructions to: obtain a request to render animage of a visualization included in a client app; analyze the renderrequest to determine data required for render processing; provide arequest for the data required for render processing; obtain the datarequired for render processing upon providing the request for therequired data; recreate an app state of the client app using theobtained data required for render processing, the recreated app stateincluding data related to the visualization included in the client app;and render the image of the visualization included in the client appusing the recreated app state.
 10. The system of claim 9, theinstructions further comprising instructions to: generate a publishingelement using the rendered image of the visualization included in theclient app; and provide the publishing element for publication.
 11. Thesystem of claim 9, wherein the client app is included in an Adobe Flashobject.
 12. The system of claim 9, wherein the client app includes amassively multiplayer gaming application.
 13. The system of claim 9,wherein providing a request for the data required for render processingincludes querying a database for the required data.
 14. The system ofclaim 9, wherein the request for the data required for render processingis provided for a client executing the client app.
 15. The system ofclaim 10, wherein the publishing element includes a message for postingon a Facebook webpage.
 16. The system of claim 9, wherein the image ofthe visualization included in the client app is rendered in one of:JPEG; GIF; PNG; and BMP formats.
 17. A processor-readable medium storingprocessor-executable distributed rendering instructions, theinstructions comprising instructions to: obtain a request to render animage of a visualization included in a client app; analyze the renderrequest to determine data required for render processing; provide arequest for the data required for render processing; obtain the datarequired for render processing upon providing the request for therequired data; recreate an app state of the client app using theobtained data required for render processing, the recreated app stateincluding data related to the visualization included in the client app;and render the image of the visualization included in the client appusing the recreated app state.
 18. The medium of claim 17, theinstructions further comprising instructions to: generate a publishingelement using the rendered image of the visualization included in theclient app; and provide the publishing element for publication.
 19. Themedium of claim 17, wherein the client app is included in an Adobe Flashobject.
 20. The medium of claim 17, wherein the client app includes amassively multiplayer gaming application.
 21. The medium of claim 17,wherein providing a request for the data required for render processingincludes querying a database for the required data.
 22. The medium ofclaim 17, wherein the request for the data required for renderprocessing is provided for a client executing the client app.
 23. Themedium of claim 18, wherein the publishing element includes a messagefor posting on a Facebook webpage.
 24. The medium of claim 17, whereinthe image of the visualization included in the client app is rendered inone of: JPEG; GIF; PNG; and BMP formats.
 25. A processor-implementedrendering request method, comprising: obtaining a client app from an appdatabase; obtaining user input from a user for the client app;generating data pertaining to a visualization included in the client appbased on the obtained user input; providing a request for rendering animage of the visualization included in the client app; and providing thedata pertaining to the visualization for processing the request forrendering the image of the visualization included in the client app. 26.The method of claim 25, further comprising: providing an indication topublish the image of the visualization included in the client app. 27.The method of claim 25, further comprising: obtaining data associatedwith the client app and pertaining to a member of a social graph of theuser; and wherein generating data pertaining to the visualizationincluded in the client app is further based on the obtained datapertaining to the member of the social graph of the user.
 28. The methodof claim 25, wherein the client app includes a massively multiplayergaming application.
 29. The method of claim 25, wherein the client appis included in an Adobe Flash object.
 30. The method of claim 25,wherein providing the data pertaining to the visualization forprocessing the request for rendering the image includes: freezing astate of the client app; and obtaining a snapshot of the frozen state ofthe client app.
 31. The method of claim 26, wherein the indicationincludes an indication to publish the image of the visualizationincluded in the client app to a Facebook webpage.
 32. A renderingrequest apparatus, comprising: a processor; and a memory disposed incommunication with the processor and storing processor-executableinstructions, the instructions comprising instructions to: obtain aclient app from an app database; obtain user input from a user for theclient app; generate data pertaining to a visualization included in theclient app based on the obtained user input; provide a request forrendering an image of the visualization included in the client app; andprovide the data pertaining to the visualization for processing therequest for rendering the image of the visualization included in theclient app.
 33. The apparatus of claim 32, the instructions furthercomprising instructions to: provide an indication to publish the imageof the visualization included in the client app.
 34. The apparatus ofclaim 32, the instructions further comprising instructions to: obtaindata associated with the client app and pertaining to a member of asocial graph of the user; and wherein generating data pertaining to thevisualization included in the client app is further based on theobtained data pertaining to the member of the social graph of the user.35. The apparatus of claim 32, wherein the client app includes amassively multiplayer gaming application.
 36. The apparatus of claim 32,wherein the client app is included in an Adobe Flash object.
 37. Theapparatus of claim 32, wherein the instructions to provide the datapertaining to the visualization for processing the request for renderingthe image include instructions to: freeze a state of the client app; andobtain a snapshot of the frozen state of the client app.
 38. Theapparatus of claim 33, wherein the indication includes an indication topublish the image of the visualization included in the client app to aFacebook webpage.
 39. A processor-readable medium storingprocessor-executable rendering request instructions, the instructionscomprising instructions to: obtain a client app from an app database;obtain user input from a user for the client app; generate datapertaining to a visualization included in the client app based on theobtained user input; provide a request for rendering an image of thevisualization included in the client app; and provide the datapertaining to the visualization for processing the request for renderingthe image of the visualization included in the client app.
 40. Themedium of claim 39, the instructions further comprising instructions to:provide an indication to publish the image of the visualization includedin the client app.
 41. The medium of claim 39, the instructions furthercomprising instructions to: obtain data associated with the client appand pertaining to a member of a social graph of the user; and whereingenerating data pertaining to the visualization included in the clientapp is further based on the obtained data pertaining to the member ofthe social graph of the user.
 42. The medium of claim 39, wherein theclient app includes a massively multiplayer gaming application.
 43. Themedium of claim 39, wherein the client app is included in an Adobe Flashobject.
 44. The medium of claim 39, wherein the instructions to providethe data pertaining to the visualization for processing the request forrendering the image include instructions to: freeze a state of theclient app; and obtain a snapshot of the frozen state of the client app.45. The medium of claim 40, wherein the indication includes anindication to publish the image of the visualization included in theclient app to a Facebook webpage.